diff --git a/CLAUDE.md b/CLAUDE.md index 3730214..f083041 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1324,6 +1324,69 @@ 15 条 `/api/gov/mail/*` 路由**全部归运营中心 `ops`**(读写都不给设计端 —— 邮箱那一屏没有设计端消费方,入站正文是客户来往内容, 见 ADR-013 决策 10);前端未做,照 `docs/前端对接说明-邮件收发.md`。新依赖 imapflow / nodemailer@8 / postal-mime。 欠账(debt):event 按 cause.ref 幂等、IDLE、wecom 无 Message-ID、channel 无 upsert 路由(共十五笔见 debt.md)。 +- **「工作台疯狂轮询三个接口」= 两台后端互桥回弹的广播风暴**(2026-08-26 用户报):前端没有任何轮询 + (`refetchInterval` 全仓只在测试台),是 SSE 在以每秒几千条的速度推 `system` touch —— 挂在库的 + `jcai_touch` 频道上实测 **45 秒 192,270 条**,全是同一条 `POST /api/gov/process/validate`, + 在 8787 与 8790 两个进程之间严格交替、条数相等。病根 `broadcast-bridge.ts`:收到别人的 NOTIFY 就 + `broadcaster.publish` 到本地,而桥自己也订阅着这个 broadcaster,那条转发被当成「自己推的」再 NOTIFY + 一遍(from 换成自己)→ 对面不是它发的、再转发、再 NOTIFY……「自己发的自己不收」只挡一跳,两台接力 + 就是永动机;08-24 验桥时只有一台在跑,没有第二方回弹。修:转发进来的那条打记号(WeakSet,publish + 同步派发),「本地 → 库」那一侧认出记号就不发;`bridgeBroadcaster` 第三参 `self` 可注入(同进程两座桥 + 才模拟得出两台机器)。2 测:转发不再 NOTIFY 出去 · 两台互桥一条广播各到一次就停(假频道封顶 50 条, + 让用例失败而不是把测试进程撑爆 —— 第一版真·无限递归 OOM 了)。两侧任一打上补丁回弹即断。 + 连带看见但未动:`task-service.tick` 每拍无条件 `setPhase` 广播 + 每拍推帧 + 推进器 `advanced`,一拍 + 3-4 条 `task` touch,前端 `invalidateFor` 无合并 —— 推送有多密请求就有多密(记 debt)。 + +- **第三个活动 ACT-WORK-05 差异评估已入库并全流程走查**(2026-08-27,`part-substitution-assessment@1.2.6`): + 原 PN 与候选替代料**逐项差异评估** —— 比参数、判四态(MATCH / MISMATCH / UNKNOWN / CONDITIONAL)、 + 定推荐等级(推荐 / 条件推荐 / 备选 / 不推荐)、留证据与验证任务,落 P-11(替代关系 + 差异明细)、 + 回写 P-01,发一口 `assessment-released` 交 ACT-GATE-03。 + **九个计划项**(五处不给 doneWhen):S0_bind → S0d_p08_master / S0d_p10_document(两张数据工单各一份件 —— + 一个计划项只能绑一份画面,不能共用)→ S1_input_confirm(唯一的执行工单,零输入)→ S2_normalize → + S3_assess(两枚纯函数工具:`compare-parameters` / `recommend`)→ S4_review(决策卡循环)→ + S5_prepare_landing → T_release。 + **新建 4 域 7 张主数据表**(`parts.profile` / **`parts.parameter` 子表** / `parts.document` / `demand.request` / + `substitution.relation` / `substitution.difference_item` / `validation.record`),主数据域 4 → 8。 + 五张模版**逐字节搬自目标件**(`views/target-style.ts` 是抽取的原样式表,不用 E04/I01 的外壳)。 + **六轮浏览器走查全部 `released`**(都在库常路 / 候选缺库 / 三候选含硬约束不推荐 / 原PN缺库硬阻塞 / + 新客户建档 / 录入卡复验),覆盖决策卡、审核驳回循环、终局重做循环、数据录入卡四条人环分支; + 逐单 SQL 复核落账(`customer_approval_status` 每单留空 —— 只读边界守住,`rule_version` 随结论落账)。 + 逐轮结论与 A–K 十一条发现见 `docs/ACT-WORK-05-端到端测试记录.md`,字段口径见 `docs/数据域字段说明-W05.md`。 + **三条值得记住的**:①**「机检只读基座数」第六次现形,这次是存在性不是计数** —— + 原 PN 根本不在库而模型判「在库」,剧本已写到头;治法是 `pn_check.found_pn_ref` + (`refersTo: parts.profile.internal_pn` + `requiredWhen: {exists_status: found}`)—— + **判在库就必须拿得出一个基座查得到的料号**,查无此值当场拒、填不出则收不了步。 + ②**模型会压拍,压过之后只有说明书还在**(第四次):S1 的「先写清单再发卡」只在剧本里, + 压拍那一拍卡发出去而清单一行没有,人对着空表;规矩搬进说明书。 + ③**措辞治不了的结构治,但先分清「已经说过」与「从没说过」**:同一天的发现 I 是前者(该上结构), + 发现 J(数据工单派给了在库的那颗)是后者 —— 剧本从没写过「found 的不建」,补一句话就够。 + 平台侧四条欠账已记 debt(`disable` 无路可走 · 前一项不收掉后一项的件推不出来 · + 拒回数不出「缺的是一次工具调用」· 零行台账的提交闸无牙)。 + +- **脚本 e2e 逼出的八条:两条线逮到的缺陷不重合**(2026-08-27,`w05` 五案例连跑六轮): + 浏览器走查逮**人看见什么、点得动什么**;脚本逮**机制** —— 它每张卡都先空手交一次、 + 每个岔路口按序代答,而人手点的时候永远不会去试「空着交上去会怎样」。**发现 L–S 八条, + 没有一条是浏览器那六轮逮到的**。末轮:跑到的四例全部 released、三例被拒 0 + (第五例停在大模型账户 `Insufficient Balance`,不是代码问题)。 + 平台侧六条(全部有测):①**闸看错了表** —— 卡没绑表就回落到必交付物,而数据工单要人补的是 + `parts.*` 主数据、不在交付物名单里:闸盯着一堆无关的表、一格不缺,空手交卷一路放行。 + 契约新增 `ExecutionWorkOrder.gateLedgers`(**这张卡该拦哪几张表,发卡的人说了算**), + `gateAddressesOf` 变三级取一(绑的表 > 卡自报 > 交付物);②**拒回数不出「缺的是一次工具调用」** —— + `finish` 撞 doneWhen 为假时只谈「行与列」,现在摆判据原文 + 那几个名字此刻的读数, + `tool_*_calls` 读到 0 的单独点名;③**拒回喂指针没用**:人点了决策卡、模型每拍再发一张, + 把「他选的是 approve」写进拒回**照发不误** —— 下一拍它又从头翻一次会滚走的窗口; + 改结构 `answeredCardFact`,把「这张卡已答过 → 他选的是什么」做成**每拍都在的事实行** + (worldTouched 2026-08-21、E04 事实行 2026-08-24 之后同一条道理的第三次); + ④模型传 `requirement: null` 把工具打崩(边界上一律经 `text()` 归一); + ⑤拒回里的 `count=(没写过)` 是 S-FEEL 函数名被当成台账名 —— **假线索模型会去追**; + ⑥**零行 = 零缺**:模型压拍没写骨架就发数据工单,人打开是空表,闸与哨兵一起放过 + (`emptyGate`:卡自报的表一行都没有 = 没完成);⑦**「早收」不该算撞墙** —— + 工具还没轮到调 `finish` 先到了,那是计划次序的小错,头一次只落观察、第二次起才算被拒 + (与「重发已答过的卡」同一把尺)。 + 活动侧 1.2.9:三张执行工单各自声明 `gateLedgers`;说明书补「发卡前骨架必须先有行」与 + S1 那张卡的前提(一颗 absent 都不剩);哨兵 `parts_profile_rows >= created` 逐颗对账。 + e2e 脚本加 `JCAI_E2E_BEARER` 直供旁路(卡会落到 token 主人的工作台、不续期; + 服务账号 `client_credentials` 仍是正路)。 ## 文档权威地图 @@ -1337,6 +1400,8 @@ | | `docs/前端对接说明-邮件收发.md` | **前端接邮箱配置 / 来信 / 发信记录照这份**(ADR-013):账号表单两形、四个动作、投递状态、附件与原件的票据下载、SSE 失效、腾讯侧前置 | | | `docs/API文档-邮件收发.md` | 邮件收发 15 条接口的人话版 + schema 附录 + curl;活动怎么收(事件链)怎么发(`mail.send` 2.0.0) | | | `docs/API文档-鉴权与人员.md` | 鉴权 / 人员 / 角色→端接口的人话版 + 全部路由归属总表;契约不一致时以 `packages/contracts` 为准 | +| | `docs/ACT-WORK-05-端到端测试记录.md` | **ACT-WORK-05 差异评估的走查账**:六轮逐轮结论 + A–K 十一条发现总表(现象 / 病根 / 治法 / 层) | +| | `docs/数据域字段说明-W05.md` | ACT-WORK-05 的十张台账 / 110 列 / 人填列 27 —— 建活动时照它对字段 | | | `docs/debt.md` | 欠账台账(只增,销账划线) | | | `docs/adr/` · 各模块 `CONTRACT.md` | 架构决策与模块级不变量 | | 业务样例(活) | `docs/MVP示例工作流.html` | 七节点 SOP + 判定表 + 台账域 —— 开发活动的业务素材 | diff --git a/activities/part-substitution-assessment/__tests__/activity.test.ts b/activities/part-substitution-assessment/__tests__/activity.test.ts new file mode 100644 index 0000000..57825e8 --- /dev/null +++ b/activities/part-substitution-assessment/__tests__/activity.test.ts @@ -0,0 +1,398 @@ +/** + * ACT-WORK-05 差异评估的包内自测 —— **只准 import @sdk / @contracts / @sfeel**。 + * 案例活动没有 `run`,自测不跑回合;测的是清单本身与授权面对齐,结构照 E04 / I01。 + * + * 七组:清单本身合规 / 台账声明 / 案例模型与清单的对齐 / 报告模版:编辑面与只读面各就各位 / + * 徽标别名与值域相关的坑(2026-08-27 实测账,回归网)/ 可编辑件的主键与必填列 + * (2026-08-27 复审,回归网)/ 活动入口。 + */ +import { describe, expect, it } from 'vitest'; +import { activityManifestSchema } from '@contracts'; +import { createMockHost } from '@sdk'; +import { manifest, D, RULE_VERSION } from '../src/manifest.ts'; +import activity from '../src/index.ts'; + +const ITEMS = ['S0_bind', 'S0d_p08_master', 'S0d_p10_document', 'S1_input_confirm', 'S2_normalize', 'S3_assess', 'S4_review', 'S5_prepare_landing', 'T_release']; +const NO_DONE_WHEN = new Set(['S0d_p08_master', 'S0d_p10_document', 'S1_input_confirm', 'S4_review', 'T_release']); +const VIEWS = ['p08-master-create', 'p10-document-create', 'eval-input-list', 'difference-review', 'landing-confirm']; +const byAddress = (domain: string, object: string) => manifest.declarations.ledger.find((l) => l.domain === domain && l.object === object); +const viewHtml = (name: string) => manifest.assets.viewTemplates.find((t) => t.name === name)?.html ?? ''; + +describe('清单本身合规', () => { + it('过 @contracts 的 schema', () => { + expect(() => activityManifestSchema.parse(manifest)).not.toThrow(); + }); + + it('没有静态监听(等外部回音一律落在执行工单上,listen 在本仓不可用)', () => { + expect(manifest.declarations.listeners).toEqual([]); + }); + + it('L1/L2 判据都给了谓词;L4 三条不给(裁量项);L5 恰一条', () => { + for (const c of manifest.contract.acceptanceCriteria) { + if (c.level === 'L1' || c.level === 'L2') expect(c.predicate, c.key).toBeDefined(); + if (c.level === 'L4') expect(c.predicate, c.key).toBeUndefined(); + } + expect(manifest.contract.acceptanceCriteria.filter((c) => c.level === 'L4')).toHaveLength(3); + expect(manifest.contract.acceptanceCriteria.filter((c) => c.level === 'L5')).toHaveLength(1); + }); + + it('机检谓词只读基座读数与记账旗:不出现活动自报的汇总列名', () => { + const forbidden = ['relation_total', 'candidate_total', 'recommended_total', 'not_recommended_total']; + for (const c of manifest.contract.acceptanceCriteria) { + for (const name of forbidden) expect(c.predicate ?? '', `${c.key} 读了自报数 ${name}`).not.toContain(name); + } + }); + + it('三件必交付物都有台账地址;人环预算严格大于「基线 8 + 两轮审核循环 4」', () => { + expect(manifest.contract.requiredDeliverables).toHaveLength(3); + for (const d of manifest.contract.requiredDeliverables) expect(d.ledger, d.key).toBeDefined(); + expect(manifest.contract.authorization.humanCallBudget).toBeGreaterThan(12); + expect(manifest.contract.resources.budget.humanCalls).toBeGreaterThan(12); + }); + + it('起单只必填 4 项(客户 / 需求 / 原 PN / 候选数组);datasheet 是选填文件', () => { + expect(manifest.contract.input.data['required']).toEqual(['customerCode', 'requestDescription', 'originalInternalPn', 'candidateInternalPns']); + const properties = manifest.contract.input.data['properties'] as Record; + expect(properties['candidateInternalPns']?.type).toBe('array'); + expect(properties['datasheets']?.format).toBe('file'); + }); + + it('五条样例:第一条满载走数据工单那条路,名字 ≤14 字,形状各不相同', () => { + expect(manifest.samples).toHaveLength(5); + for (const s of manifest.samples) expect(s.name.length, s.name).toBeLessThanOrEqual(14); + expect(new Set(manifest.samples.map((s) => JSON.stringify(s.input))).size).toBe(5); + const first = manifest.samples[0]?.input as { candidateInternalPns?: string[] }; + expect(first.candidateInternalPns).toContain('XL2596S-5.0'); + const newCustomer = manifest.samples.find((s) => (s.input as { customerName?: string }).customerName !== undefined); + expect(newCustomer).toBeDefined(); + }); + + it('五张视图模版都声明了,剧本每一步引用的 view 都在其中', () => { + expect(new Set(manifest.assets.viewTemplates.map((v) => v.name))).toEqual(new Set(VIEWS)); + for (const step of manifest.assets.businessModel.steps as ReadonlyArray<{ view?: string }>) { + if (step.view !== undefined) expect(VIEWS, step.view).toContain(step.view); + } + }); +}); + +describe('台账声明:授权面与《统一方案》口径', () => { + it('P-08 主键 internal_pn,标准化参数集拆成独立子表 parts.parameter(2026-08-27 结构改:与目标件一致)', () => { + const p08 = byAddress('parts', 'profile'); + expect(p08?.fields.filter((f) => f.primaryKey).map((f) => f.name)).toEqual(['internal_pn']); + expect(p08?.fields.find((f) => f.name === 'normalized_parameter_set')).toBeUndefined(); + const param = byAddress('parts', 'parameter'); + expect(param?.kind).toBe('master'); + expect(param?.fields.filter((f) => f.primaryKey).map((f) => f.name)).toEqual(['internal_pn', 'param_name']); + expect(param?.fields.find((f) => f.name === 'internal_pn')?.refersTo).toBe('parts.profile.internal_pn'); + /* + * 参数名自指引用:只能用台账里已经在用的那几个 —— 2026-08-27 实测三次, + * 模型给新料写英文 key,剧本写过两遍 + 一条乘法对账都拦不住「只建一颗」那一路。 + */ + const pn = param?.fields.find((f) => f.name === 'param_name'); + expect(pn?.refersTo).toBe('parts.parameter.param_name'); + expect(pn?.distinct).toBe(true); + expect(param?.fields.find((f) => f.name === 'param_value')?.required).toBe(true); + expect(param?.fields.find((f) => f.name === 'constraint_type')?.tally).toEqual(['hard', 'soft']); + expect(param?.fields.find((f) => f.name === 'constraint_type')?.required).toBe(true); + }); + + it('P-11 主记录的原 PN / 候选 PN 都是引用墙(查无此料当场拒 —— 存在性检查的硬门)', () => { + const rel = byAddress('substitution', 'relation'); + for (const name of ['original_internal_pn', 'candidate_internal_pn']) { + expect(rel?.fields.find((f) => f.name === name)?.refersTo, name).toBe('parts.profile.internal_pn'); + } + }); + + it('客户批准状态**不在声明里**:本活动没有它的写权(只读边界)', () => { + const rel = byAddress('substitution', 'relation'); + expect(rel?.fields.map((f) => f.name)).not.toContain('customer_approval_status'); + }); + + it('UNKNOWN 必有去向:unknown_disposition 钉在 difference_status = unknown 的行上;四态是 ASCII tally', () => { + const item = byAddress('substitution', 'difference_item'); + expect(item?.fields.find((f) => f.name === 'unknown_disposition')?.requiredWhen).toEqual({ column: 'difference_status', value: 'unknown' }); + expect(item?.fields.find((f) => f.name === 'difference_status')?.tally).toEqual(['match', 'mismatch', 'unknown', 'conditional']); + expect(item?.fields.find((f) => f.name === 'substitution_relation_id')?.distinct).toBe(true); + }); + + it('P-01 回写五项钉在 current_stage = gate03 那一刻(放行前不拦,放行门 L2 数得出来)', () => { + const p01 = byAddress('demand', 'request'); + for (const name of ['risk_level', 'verification_requirement', 'output_ref', 'next_action', 'current_activity']) { + expect(p01?.fields.find((f) => f.name === name)?.requiredWhen, name).toEqual({ column: 'current_stage', value: 'gate03' }); + } + }); + + it('自持单据都带 caseKey eval_ref 且在主键里;放弃候选必须写原因', () => { + for (const object of ['pn_check', 'input_gap', 'verdict']) { + const t = byAddress(D, object); + expect(t?.kind, object).toBe('record'); + expect(t?.caseKey, object).toBe('eval_ref'); + expect(t?.fields.find((f) => f.name === 'eval_ref')?.primaryKey, object).toBe(true); + } + expect(byAddress(D, 'pn_check')?.fields.find((f) => f.name === 'abandon_reason')?.requiredWhen).toEqual({ column: 'exists_status', value: 'abandoned' }); + }); + + it('判「在库」必须填得出引用依据,基座拿它去主数据里查(2026-08-27 实测:原 PN 不在库而模型把两颗都写成 found,硬阻塞那条路整个被跳过)', () => { + const ref = byAddress(D, 'pn_check')?.fields.find((f) => f.name === 'found_pn_ref'); + expect(ref?.refersTo).toBe('parts.profile.internal_pn'); + expect(ref?.requiredWhen).toEqual({ column: 'exists_status', value: 'found' }); + expect(ref?.primaryKey ?? false).toBe(false); + }); + + it('规则版本常量随包冻结', () => { + expect(RULE_VERSION).toBe('R-2026.07'); + expect(manifest.assets.businessModel.dmn.tables.map((t) => t.id)).toEqual(['d01-difference-status', 'd02-recommendation']); + }); +}); + +describe('案例模型与清单的对齐', () => { + it('九个计划项,剧本 item 与 CMMN humanTask id 一一对应', () => { + const cmmnIds = [...manifest.assets.businessModel.cmmnXml.matchAll(/ m[1] ?? ''); + expect(cmmnIds).toEqual(ITEMS); + expect((manifest.assets.businessModel.steps as ReadonlyArray<{ item: string }>).map((s) => s.item)).toEqual(ITEMS); + }); + + it('五处不给 doneWhen(两张数据工单 / 输入确认 / 审核 / 放行),其余四处都给', () => { + for (const s of manifest.assets.businessModel.steps as ReadonlyArray<{ item: string; doneWhen?: string }>) { + if (NO_DONE_WHEN.has(s.item)) expect(s.doneWhen, s.item).toBeUndefined(); + else expect(s.doneWhen, s.item).toBeDefined(); + } + }); + + it('两张数据工单件各自绑自己的 view(P-08 与 P-10 不共用同一份画面)', () => { + const steps = manifest.assets.businessModel.steps as ReadonlyArray<{ item: string; view?: string }>; + expect(steps.find((s) => s.item === 'S0d_p08_master')?.view).toBe('p08-master-create'); + expect(steps.find((s) => s.item === 'S0d_p10_document')?.view).toBe('p10-document-create'); + }); + + it('那五项在 CMMN 里都标了人工激活', () => { + for (const id of NO_DONE_WHEN) { + const block = new RegExp(``).exec(manifest.assets.businessModel.cmmnXml)?.[0] ?? ''; + expect(block, id).toContain('manualActivationRule'); + } + }); + + it('除放行外每一项恰好属于一个阶段;5 段 + 放行 = x/6,与文档 0.5/1/2/3/4/5 六步对齐', () => { + const phases = manifest.assets.businessModel.phases ?? []; + expect(phases).toHaveLength(5); + const phaseItems = phases.flatMap((p) => p.items); + expect([...phaseItems].sort()).toEqual([...ITEMS.filter((i) => i !== 'T_release')].sort()); + expect(new Set(phaseItems).size).toBe(phaseItems.length); + }); + + it('说明书点名的计划项都真实存在', () => { + const mentioned = [...manifest.assets.businessModel.narrative.matchAll(/\b(S\d[a-z]?_[a-zA-Z_]+|T_release)\b/g)].map((m) => m[1] ?? ''); + for (const name of mentioned) expect(ITEMS, `说明书提到但不存在的计划项: ${name}`).toContain(name); + }); + + it('两种决策卡骨架都在说明书里:候选放弃/创建(create/abandon)与审核(approve/reject/custom:)', () => { + const n = manifest.assets.businessModel.narrative; + expect(n).toContain('"kind":"decide","itemId":"S0d_p08_master"'); + expect(n).toContain('"value":"create"'); + expect(n).toContain('"value":"abandon"'); + expect(n).toContain('"kind":"decide","itemId":"S4_review"'); + expect(n).toContain('"approve"'); + expect(n).toContain('"reject"'); + expect(n).toContain('"custom:"'); + }); + + it('T_release 剧本里 judge criterion 的原文逐字对得上 acceptanceCriteria 的 label', () => { + const tRelease = (manifest.assets.businessModel.steps as ReadonlyArray<{ item: string; guide?: string }>).find((s) => s.item === 'T_release'); + const quoted = [...(tRelease?.guide ?? '').matchAll(/judge criterion="([^"]+)"/g)].map((m) => m[1] ?? ''); + expect(quoted).toHaveLength(3); + const labels = new Set(manifest.contract.acceptanceCriteria.map((c) => c.label)); + for (const q of quoted) expect(labels.has(q), q).toBe(true); + }); +}); + +describe('报告模版:编辑面与只读面各就各位', () => { + it('P-08 数据工单件的表 1 + 表 2(标准化参数子表)都可加行可编辑:data-edit / data-edit-add 与主键 data-col 都在', () => { + const p08 = viewHtml('p08-master-create'); + expect(p08).toContain('data-edit="parts.profile"'); + expect(p08).toContain('data-edit-add="parts.profile"'); + expect(p08).toContain('data-col="internal_pn"'); + expect(p08).toContain('data-edit="parts.parameter"'); + expect(p08).toContain('data-edit-add="parts.parameter"'); + expect(p08).toContain('data-col="param_name"'); + expect(p08).toContain('data-col="param_value"'); + expect(p08).toContain('data-col="constraint_type"'); + const p10 = viewHtml('p10-document-create'); + expect(p10).toContain('data-edit="parts.document"'); + expect(p10).toContain('data-col="doc_seq"'); + }); + + it('评估输入清单:缺口表可编辑(supplement),绑定区只读', () => { + const html = viewHtml('eval-input-list'); + expect(html).toContain(`data-edit="${D}.input_gap"`); + expect(html).toContain('data-col="supplement"'); + expect(html).toContain(`data-rows="mine:${D}.pn_check"`); + }); + + it('差异审核与落账确认只读:没有任何 data-edit / data-col', () => { + for (const name of ['difference-review', 'landing-confirm']) { + expect(viewHtml(name), name).not.toContain('data-edit='); + expect(viewHtml(name), name).not.toContain('data-col='); + } + }); + + it('每个可编辑格子的 data-col 都在对应台账对象的声明里(p08-master-create 一屏两张表,两张台账对象的声明并起来看)', () => { + const cases: Array<[string, Array<[string, string]>]> = [ + ['p08-master-create', [['parts', 'profile'], ['parts', 'parameter']]], + ['p10-document-create', [['parts', 'document']]], + ['eval-input-list', [[D, 'input_gap']]], + ]; + for (const [view, objects] of cases) { + const cols = new Set([...viewHtml(view).matchAll(/data-col="([^"]+)"/g)].map((m) => m[1] ?? '')); + const declared = new Set(objects.flatMap(([domain, object]) => byAddress(domain, object)?.fields.map((f) => f.name) ?? [])); + for (const c of cols) expect(declared.has(c), `${view}: ${c}`).toBe(true); + } + }); + + it('枚举列只用 data-class-of 投影,不摆 ASCII 原值', () => { + expect(viewHtml('difference-review')).toContain('data-class-of="difference_status"'); + expect(viewHtml('difference-review')).toContain('data-class-of="recommendation_level"'); + expect(viewHtml('difference-review')).not.toContain('data-slot="difference_status"'); + const landing = viewHtml('landing-confirm'); + for (const col of ['request_status', 'current_stage', 'analysis_status', 'recommendation_level']) { + expect(landing, col).toContain(`data-class-of="${col}"`); + expect(landing, col).not.toContain(`data-slot="${col}"`); + } + }); + + it('宿主拒推含脚本的模版', async () => { + const host = createMockHost({ contract: CONTRACT }); + await expect(host.base.interaction.pushHtml('
')).rejects.toThrow(/无脚本执行权/); + }); + + it('五张模版的外壳都是搬自目标件的 page/card,不再含 E04/I01 那套视觉底(.proto-root)的痕迹', () => { + for (const view of VIEWS) { + const html = viewHtml(view); + expect(html, view).toContain('class="card-head"'); + expect(html, view).toContain('class="card-foot"'); + expect(html, view).not.toContain('proto-root'); + } + }); +}); + +/* + * 2026-08-27 实测账,两条都真截图 + SQL 复核过: + * ① **带下划线的枚举值一律显示成「待定」**——平台有两套互相打架的消毒规则: + * `data-class-of` 投影出的 class 走 `view-render.ts` 的 `classToken`(只留 `[a-z0-9-]`, + * 吃掉下划线,`pin_to_pin` → `v-pintopin`);基座读数名走 `engines.ts` 的 `slug` + * (只留 `[a-z0-9_]`,吃掉连字符)。手写 `.v-pin_to_pin` 那种选择器永远匹配不上 —— + * 这条测试把 `manifest.declarations.ledger` 里每一个「模版真的摆了徽标」的 tally 列过一遍, + * 用与 `classToken` 一字不差的 `vtok` 算出选择器,断言对应的 CSS 规则确实存在。 + * ② **缺口表补充内容每一行都摆红「必填」,而闸只认 3 行**——`requiredWhen` 是按行不按列, + * 静态 `class="req"` 把整列都标了必填。 + */ +describe('徽标别名与值域相关的坑(2026-08-27 实测账,回归网)', () => { + /** 必须与 `apps/api/src/modules/interaction/internal/domain/view-render.ts` 的 `classToken` 一字不差 */ + const vtok = (v: string): string => v.toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 24); + + /** 每张模版真的摆了徽标的那几列(带下划线的 tally 值最容易漏,漏了就是「待定」那次事故) */ + const BADGED: ReadonlyArray<{ view: string; domain: string; object: string; column: string }> = [ + { view: 'p08-master-create', domain: 'parts', object: 'profile', column: 'lifecycle_status' }, + { view: 'p08-master-create', domain: 'parts', object: 'parameter', column: 'constraint_type' }, + { view: 'p10-document-create', domain: 'parts', object: 'document', column: 'document_type' }, + { view: 'p10-document-create', domain: 'parts', object: 'document', column: 'document_status' }, + { view: 'eval-input-list', domain: D, object: 'pn_check', column: 'exists_status' }, + { view: 'eval-input-list', domain: D, object: 'pn_check', column: 'role' }, + { view: 'eval-input-list', domain: D, object: 'input_gap', column: 'status' }, + { view: 'difference-review', domain: 'substitution', object: 'relation', column: 'substitution_type' }, + { view: 'difference-review', domain: 'substitution', object: 'relation', column: 'recommendation_level' }, + { view: 'difference-review', domain: 'substitution', object: 'relation', column: 'risk_level' }, + { view: 'difference-review', domain: 'substitution', object: 'difference_item', column: 'constraint_type' }, + { view: 'difference-review', domain: 'substitution', object: 'difference_item', column: 'difference_status' }, + { view: 'difference-review', domain: 'substitution', object: 'difference_item', column: 'risk_level' }, + { view: 'landing-confirm', domain: 'substitution', object: 'relation', column: 'substitution_type' }, + { view: 'landing-confirm', domain: 'substitution', object: 'relation', column: 'recommendation_level' }, + { view: 'landing-confirm', domain: 'substitution', object: 'relation', column: 'analysis_status' }, + { view: 'landing-confirm', domain: 'substitution', object: 'relation', column: 'risk_level' }, + { view: 'landing-confirm', domain: 'demand', object: 'request', column: 'request_status' }, + ]; + + it('每张模版摆了徽标的每个 tally 列,声明里的每个值都有对应的 v- 规则(选择器是从值算出来的,不是手写的)', () => { + for (const { view, domain, object, column } of BADGED) { + const tally = byAddress(domain, object)?.fields.find((f) => f.name === column)?.tally ?? []; + expect(tally.length, `${domain}.${object}.${column} 没有声明 tally`).toBeGreaterThan(0); + const html = viewHtml(view); + for (const value of tally) { + expect(html, `${view}: ${domain}.${object}.${column}=${value} → 应有 .v-${vtok(value)}::after`).toContain(`.v-${vtok(value)}::after`); + } + } + }); + + it('缺口表补充内容按行投影必填,不是整列静态 req(requiredWhen 是按行的,不是按列的)', () => { + const html = viewHtml('eval-input-list'); + expect(html).not.toContain('class="req" data-h="补充内容"'); + expect(html).toContain('data-class-of="status"'); + expect(html).toContain('.sup.v-gap'); + }); +}); + +/* + * 2026-08-27 定向复审逮住的两条 Critical(都是这一轮版面重做新引入的回归,不是原有的坑): + * ① `sub_eval.input_gap` 的「键」(`item_key`)那一格丢了 `data-col` —— 一单 11 行,`item_key` + * 逐行不同,人保存**任何一行**时服务端 `resolveRowKey` 凑不出主键(它既不在件上、 + * 又不是「全表一致」的那种案号型列),整格落不下去; + * ② `sub_eval.input_gap.status` 声明 `required: true`,件上又有「＋ 加一行」—— + * 降成只读徽标后,人新加的行永远没有格子能把这一列填上,`_missing` 恒为正、 + * 提交闸永远拦着,这是「墙不配路」的死路形态。 + * 两条各配一张回归网,防的是同一类事故再出现在别的字段上。 + */ +describe('可编辑件的主键与必填列(2026-08-27 复审:主键丢钥匙 / 必填填不了,两条 Critical 回归)', () => { + /** 三张真能编辑的件与它们各自绑定的台账对象 */ + const EDITABLE: ReadonlyArray<{ view: string; domain: string; object: string }> = [ + { view: 'p08-master-create', domain: 'parts', object: 'profile' }, + { view: 'p08-master-create', domain: 'parts', object: 'parameter' }, + { view: 'p10-document-create', domain: 'parts', object: 'document' }, + { view: 'eval-input-list', domain: D, object: 'input_gap' }, + ]; + + it('每一个主键列都有 data-col —— 它不是编辑面,是行的钥匙,丢了就整行保存不下去', () => { + for (const { view, domain, object } of EDITABLE) { + const table = byAddress(domain, object); + /* + * `caseKey` 声明的那一列(如 `eval_ref`)是例外:它是「一单一号,全表当然一致」的 + * 案号型主键(与 I01 的 `round_ref` 同款),件上压根不摆,服务端 `resolveRowKey` + * 按「全表一致」自动补上(`apps/api/src/app/routes/desk.ts` 注释里点名的那条路)—— + * 摆出来给人填反而是错的(那会让人以为能按行改案号)。真正逐行不同、必须挂 + * `data-col` 的,是主键里除 caseKey 之外的那几列(如 `item_key`)。 + */ + const pk = (table?.fields.filter((f) => f.primaryKey).map((f) => f.name) ?? []).filter((name) => name !== table?.caseKey); + expect(pk.length, `${domain}.${object} 没有非 caseKey 的主键列`).toBeGreaterThan(0); + const html = viewHtml(view); + for (const col of pk) { + expect(html, `${view}: 主键列 ${domain}.${object}.${col} 缺 data-col`).toContain(`data-col="${col}"`); + } + } + }); + + it('可编辑件上,每一个 required:true 的列都有真能填的控件(data-col)—— 必填但填不了是墙不配路', () => { + for (const { view, domain, object } of EDITABLE) { + const table = byAddress(domain, object); + const required = table?.fields.filter((f) => f.required === true).map((f) => f.name) ?? []; + expect(required.length, `${domain}.${object} 没有声明 required 列`).toBeGreaterThan(0); + const html = viewHtml(view); + for (const col of required) { + expect(html, `${view}: 必填列 ${domain}.${object}.${col} 没有可填的控件`).toContain(`data-col="${col}"`); + } + } + }); +}); + +describe('活动入口', () => { + it('没有 run —— 行为全在清单里', () => { + expect(activity.run).toBeUndefined(); + }); +}); + +const CONTRACT = { + activityId: 'part-substitution-assessment', + version: '1.0.0', + data: {}, + message: undefined, + outputPorts: { mandatory: ['assessment-released'], selective: [] }, + prohibitions: [], + discretion: [], +} as const; diff --git a/activities/part-substitution-assessment/__tests__/steps.test.ts b/activities/part-substitution-assessment/__tests__/steps.test.ts new file mode 100644 index 0000000..6a4c220 --- /dev/null +++ b/activities/part-substitution-assessment/__tests__/steps.test.ts @@ -0,0 +1,321 @@ +/** + * 步骤剧本与呈现面 —— 这段错了不报错,只是活动开始转圈 / 界面开始撒谎(与 E04 / I01 同一套惯例)。 + */ +import { describe, expect, it } from 'vitest'; +import { evaluateCondition } from '@sfeel'; +import { ASSESSMENT_PHASES, ASSESSMENT_STEPS, CMMN_XML, NARRATIVE } from '../src/case-model.ts'; +import { manifest, D } from '../src/manifest.ts'; + +const ITEM_IDS = [...CMMN_XML.matchAll(/<(?:humanTask|decisionTask|stage|milestone)\s+id="([^"]+)"/g)].map((m) => m[1] ?? ''); + +function doneOf(item: string): string { + const found = ASSESSMENT_STEPS.find((s) => s.item === item)?.doneWhen; + if (found === undefined) throw new Error(`${item} 没有 doneWhen`); + return found; +} +/** 谓词写坏了引擎当作「没算出来」——测里也照这个口径 */ +function safeEval(expression: string, scope: Record): boolean { + try { + return evaluateCondition(expression, scope); + } catch { + return false; + } +} +/** 开局局面:入参 + 所有基座读数归零 */ +const fresh = (input: Record): Record => ({ + ...input, + demand_request_rows: 0, + demand_request_missing: 0, + [`${D}_verdict_rows`]: 0, + [`${D}_pn_check_rows`]: 0, + [`${D}_pn_check_missing`]: 0, + [`${D}_pn_check_exists_status_absent`]: 0, + [`${D}_pn_check_exists_status_abandoned`]: 0, + [`${D}_input_gap_rows`]: 0, + [`${D}_input_gap_missing`]: 0, + input_confirmed_total: 0, + review_approved_total: 0, + landing_prepared_total: 0, + substitution_relation_rows: 0, + substitution_relation_missing: 0, + substitution_relation_analysis_status_fae_confirmed: 0, + substitution_difference_item_rows: 0, + substitution_difference_item_missing: 0, + substitution_difference_item_distinct_substitution_relation_id: 0, + substitution_difference_item_difference_status_match: 0, + substitution_difference_item_difference_status_mismatch: 0, + substitution_difference_item_difference_status_unknown: 0, + substitution_difference_item_difference_status_conditional: 0, + tool_part_substitution_assessment_compare_parameters_calls: 0, + tool_part_substitution_assessment_recommend_calls: 0, +}); + +describe('剧本与案例模型对得上', () => { + it('每一条剧本都指向一个真实存在的计划项,图上每一步也都有剧本', () => { + for (const step of ASSESSMENT_STEPS) expect(ITEM_IDS, `剧本里的 ${step.item} 在 CMMN 里不存在`).toContain(step.item); + for (const id of ITEM_IDS) expect(ASSESSMENT_STEPS.map((s) => s.item), `计划项 ${id} 没有剧本`).toContain(id); + }); + + it('清单里挂的就是这份剧本与这份阶段', () => { + expect(manifest.assets.businessModel.steps).toBe(ASSESSMENT_STEPS); + expect(manifest.assets.businessModel.phases).toBe(ASSESSMENT_PHASES); + }); +}); + +describe('剧本声明的读写面 ⊆ 清单声明', () => { + const declaredAddresses = new Set(manifest.declarations.ledger.map((d) => `${d.domain}.${d.object}`)); + const declaredTools = new Set(manifest.declarations.tools.map((t) => t.name)); + + it('steps[].writes / reads(台账那几个)全落在声明过的对象上', () => { + for (const step of ASSESSMENT_STEPS) { + for (const address of step.writes) expect(declaredAddresses.has(address), `${step.item} 要写 ${address}`).toBe(true); + for (const address of step.reads.filter((r) => r.includes('.') && !r.startsWith('case:'))) { + expect(declaredAddresses.has(address), `${step.item} 要读 ${address}`).toBe(true); + } + } + }); + + it('steps[].tools 全部是声明过的工具;只有 S3 调工具', () => { + for (const step of ASSESSMENT_STEPS) { + for (const tool of step.tools) expect(declaredTools.has(tool), `${step.item} 要调 ${tool}`).toBe(true); + if (step.item !== 'S3_assess') expect(step.tools, step.item).toEqual([]); + } + expect(ASSESSMENT_STEPS.find((s) => s.item === 'S3_assess')?.tools).toHaveLength(2); + }); + + it('customer_approval_status 在任何剧本里都不许写(只读边界)', () => { + for (const step of ASSESSMENT_STEPS) expect(step.guide, step.item).not.toMatch(/customer_approval_status\s*=/); + }); +}); + +describe('doneWhen —— 开局不许真,干完必须真', () => { + it('**开局一步都不该被自动收掉** —— 五条样例的入参形状逐一试', () => { + for (const sample of manifest.samples) { + for (const step of ASSESSMENT_STEPS) { + if (step.doneWhen === undefined) continue; + expect(safeEval(step.doneWhen, fresh(sample.input as Record)), `样例「${sample.name}」下 ${step.item} 开局就为真`).toBe(false); + } + } + }); + + it('S0:两颗候选 + 原 PN = 3 行核对齐、需求与结论都写了 → 收得掉;少写一颗 → 收不掉', () => { + const base = { candidateInternalPns: ['XL2596S-5.0', 'LM2596S-ADJ'], demand_request_rows: 1, demand_request_missing: 0, [`${D}_verdict_rows`]: 1, [`${D}_pn_check_missing`]: 0 }; + expect(safeEval(doneOf('S0_bind'), { ...base, [`${D}_pn_check_rows`]: 3 })).toBe(true); + expect(safeEval(doneOf('S0_bind'), { ...base, [`${D}_pn_check_rows`]: 2 })).toBe(false); + }); + + it('S2:未放弃的候选各一条关系且每条都有明细 → 收得掉;放弃一颗后关系数随之减一', () => { + const two = { candidateInternalPns: ['A', 'B'], [`${D}_pn_check_exists_status_abandoned`]: 0, substitution_difference_item_rows: 14 }; + expect(safeEval(doneOf('S2_normalize'), { ...two, substitution_relation_rows: 2, substitution_difference_item_distinct_substitution_relation_id: 2 })).toBe(true); + expect(safeEval(doneOf('S2_normalize'), { ...two, substitution_relation_rows: 2, substitution_difference_item_distinct_substitution_relation_id: 1 })).toBe(false); + expect(safeEval(doneOf('S2_normalize'), { ...two, [`${D}_pn_check_exists_status_abandoned`]: 1, substitution_relation_rows: 1, substitution_difference_item_distinct_substitution_relation_id: 1 })).toBe(true); + }); + + it('S3:四态之和 = 明细行数、必填齐、两枚工具都调过 → 收得掉;工具没调过 → 收不掉', () => { + const ok = { + substitution_difference_item_missing: 0, + substitution_relation_missing: 0, + substitution_difference_item_rows: 7, + substitution_difference_item_difference_status_match: 4, + substitution_difference_item_difference_status_mismatch: 1, + substitution_difference_item_difference_status_unknown: 1, + substitution_difference_item_difference_status_conditional: 1, + tool_part_substitution_assessment_compare_parameters_calls: 1, + tool_part_substitution_assessment_recommend_calls: 1, + }; + expect(safeEval(doneOf('S3_assess'), ok)).toBe(true); + expect(safeEval(doneOf('S3_assess'), { ...ok, tool_part_substitution_assessment_recommend_calls: 0 })).toBe(false); + expect(safeEval(doneOf('S3_assess'), { ...ok, substitution_difference_item_difference_status_match: 3 })).toBe(false); + }); + + it('S5:旗 + 全部关系 FAE 确认 + P-01 回写齐 → 收得掉;缺一头都收不掉', () => { + const ok = { landing_prepared_total: 1, substitution_relation_analysis_status_fae_confirmed: 2, substitution_relation_rows: 2, substitution_relation_missing: 0, demand_request_missing: 0 }; + expect(safeEval(doneOf('S5_prepare_landing'), ok)).toBe(true); + expect(safeEval(doneOf('S5_prepare_landing'), { ...ok, substitution_relation_analysis_status_fae_confirmed: 1 })).toBe(false); + expect(safeEval(doneOf('S5_prepare_landing'), { ...ok, demand_request_missing: 1 })).toBe(false); + }); +}); + +describe('说明书与剧本的骨架', () => { + it('五张卡的骨架都住在说明书里(压拍之后只有说明书还在)', () => { + expect(NARRATIVE).toContain('"kind":"entry","itemId":"S0_bind"'); + expect(NARRATIVE).toContain('"kind":"decide","itemId":"S0d_p08_master"'); + expect(NARRATIVE).toContain('"title":"数据工单 · 芯片主数据创建(P-08)'); + expect(NARRATIVE).toContain('"title":"数据工单 · 原厂技术资料创建(P-10)'); + expect(NARRATIVE).toContain('"title":"评估输入与资料补齐确认'); + expect(NARRATIVE).toContain('"kind":"decide","itemId":"S4_review"'); + }); + + it('剧本里不引反例原话;S3 固定三拍且写明「工具后同拍作废」', () => { + const s3 = ASSESSMENT_STEPS.find((s) => s.item === 'S3_assess')?.guide ?? ''; + expect(s3).toContain('第一拍'); + expect(s3).toContain('第二拍'); + expect(s3).toContain('第三拍'); + expect(s3).toContain('工具调用后同拍其余动作作废'); + }); + + it('S3 第三拍写盘前先自检两枚工具的调用次数(2026-08-27 实测:漏调 recommend 会让 doneWhen 恒假、模型死循环重写同样的行)', () => { + const s3 = ASSESSMENT_STEPS.find((s) => s.item === 'S3_assess')?.guide ?? ''; + const thirdPass = s3.slice(s3.indexOf('第三拍')); + expect(thirdPass).toContain('tool_part_substitution_assessment_recommend_calls'); + expect(thirdPass).toContain('tool_part_substitution_assessment_compare_parameters_calls'); + expect(thirdPass).toMatch(/自检|先.*找这两个数|必须\s*>\s*0/); + // 第二拍那一段要点出「推荐等级只能由工具算,不调它收不了步」,别让模型自己拍推荐等级 + const secondPass = s3.slice(s3.indexOf('第二拍'), s3.indexOf('第三拍')); + expect(secondPass).toContain('推荐等级只能由它算'); + expect(secondPass).toMatch(/收不了步|收不掉/); + }); + + it('S0 剧本写明都在库时数据工单两项本就不会进「当下可为」;S0d_p08_master 剧本按候选总数判断该不该问人(=1 必建、≥2 才问、原 PN 硬阻塞)', () => { + const s0 = ASSESSMENT_STEPS.find((s) => s.item === 'S0_bind')?.guide ?? ''; + expect(s0).toContain('当下可为'); + expect(s0).toContain('不要对计划项用'); + const s0d = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(s0d).toContain('硬阻塞'); + expect(s0d).toContain('候选总数 = 1'); + }); + + it('S0d_p08_master 剧本按候选总数(不是「不在库的颗数」)判断要不要问人 —— 候选总数 ≥2 时逐颗不在库的都要问(2026-08-27 实测逼出的措辞修正)', () => { + const s0d = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(s0d).toContain('候选总数'); + expect(s0d).toContain('不在库'); + expect(s0d).toMatch(/候选总数\s*≥\s*2/); + // 反面提示:「不在库的只有一颗」不该被读成跳过决策卡的理由 + expect(s0d).toContain('不是跳过决策卡的理由'); + }); + + it('s_bound 哨兵真的检查了「有料号不在库」这件事(都在库时门不该开;退回旧写法会红)', () => { + expect(CMMN_XML).toContain('sub_eval_pn_check_exists_status_absent > 0'); + const sBoundBlock = /[\s\S]*?<\/sentry>/.exec(CMMN_XML)?.[0] ?? ''; + expect(sBoundBlock).toContain('caseFileItemRef="sub_eval_pn_check_exists_status_absent"'); + expect(sBoundBlock).toContain('sub_eval_pn_check_exists_status_absent > 0'); + }); + + it('说明书与全部剧本里不会教模型对计划项调用 disable(允许出现在「不要 disable」这类禁止句里)', () => { + // 只逮「disable + 计划项 id」这种祈使形(教模型真的去调用它); + // 「不要…用 `disable`」「Disabled 只能从 Enabled 来」这类禁止句/状态名不含「disable + id」,不会被误伤。 + const disableCallPattern = /disable\s+(S\d[a-zA-Z_]*|T_release)/; + expect(NARRATIVE).not.toMatch(disableCallPattern); + for (const step of ASSESSMENT_STEPS) expect(step.guide, step.item).not.toMatch(disableCallPattern); + }); + + it('S0d 拆成两项各自绑自己的 view(P-10 那份件不会永远推不出来),两项都没有 doneWhen', () => { + const p08 = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master'); + const p10 = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p10_document'); + expect(p08?.view).toBe('p08-master-create'); + expect(p10?.view).toBe('p10-document-create'); + expect(p08?.doneWhen).toBeUndefined(); + expect(p10?.doneWhen).toBeUndefined(); + }); + + it('候选放弃到只剩最后一颗时不许再放弃(至少留一颗,防止全放弃死锁)', () => { + const s0d = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(s0d).toContain('至少留一颗候选'); + }); + + it('P-08 交回之后先 finish 再发 P-10 卡,顺序写死进两段 guide(2026-08-27 实测:漏收步会让工作区画面停在 P-08 那两张表,P-10 卡发出后人却看不见资料表、提交闸拦死)', () => { + const s0d = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(s0d).toContain('finish S0d_p08_master'); + expect(s0d).toMatch(/顺序不能反/); + expect(s0d).toContain('p08-master-create'); + const s0d10 = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p10_document')?.guide ?? ''; + expect(s0d10).toContain('finish S0d_p08_master'); + expect(s0d10).toMatch(/若它还开着|先.*finish/); + }); + + it('「发卡前清单必须先有行」写在说明书里,不只在剧本里(2026-08-27 实测:模型把 P-10 收步与 S1 发卡压成一拍,那一拍 S1 剧本没摊开,卡发出去时 input_gap 一行都没有,人对着空表无从下手)', () => { + expect(NARRATIVE).toContain('sub_eval.input_gap` 必须先有行'); + expect(NARRATIVE).toMatch(/压拍/); + expect(NARRATIVE).toMatch(/顺序不能反/); + }); + + it('存在性核对的剧本教的是「填得出依据才算在库」,不是「你看着办」(结构治,配 found_pn_ref 那道墙)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0_bind')?.guide ?? ''; + expect(g).toContain('found_pn_ref'); + expect(g).toMatch(/查无此值当场拒/); + expect(g).toMatch(/名单里没有就是没有/); + expect(g).toMatch(/把这一行改成 absent/); + }); + + it('数据工单的名单只认 absent,「建哪几颗」与「要不要问人」分开写(2026-08-27 实测:原 PN 缺库那单,模型把在库的候选派成了数据工单,缺的那颗没人建)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(g).toMatch(/问题一 · 建哪几颗/); + expect(g).toMatch(/问题二 · 建之前要不要先问人/); + expect(g).toMatch(/exists_status = "found" 的一行都不建/); + }); + + it('数据录入卡自带 basis,不让基座兜上内部家具(2026-08-27 实测:没声明 basis 的那张卡,参考信息栏摆的是「这一步 / 当下可为 / 目标缺口」加九个计划项全名)', () => { + const i = NARRATIVE.indexOf('"kind":"entry"'); + expect(i).toBeGreaterThan(-1); + const block = NARRATIVE.slice(i, i + 900); + expect(block).toContain('"basis"'); + expect(block).toContain('触发原因'); + }); + + it('三张执行工单各自声明 gateLedgers —— 零输入卡不声明,闸就盯着与它无关的表(2026-08-27 e2e 实测:两张数据工单空手交卷都放行了)', () => { + for (const [item, ledger] of [ + ['芯片主数据创建', '"gateLedgers":["parts.profile","parts.parameter"]'], + ['原厂技术资料创建', '"gateLedgers":["parts.document"]'], + ['评估输入与资料补齐确认', '"gateLedgers":["sub_eval.input_gap"]'], + ] as const) { + expect(NARRATIVE, item).toContain(ledger); + } + }); + + it('数据工单也要「先写骨架再发卡」写进说明书,且哨兵不认零行主数据(2026-08-27 e2e:模型压拍没写骨架就发卡,人打开是空表,零行同时骗过闸与哨兵,一路走到 S2 才被引用检查拦下)', () => { + // 两张数据工单各要一条(P-08 的 profile/parameter、P-10 的 document) + expect(NARRATIVE.match(/必须先有骨架行/g)?.length ?? 0).toBeGreaterThanOrEqual(2); + expect(NARRATIVE).toContain('parts.document` 必须先有骨架行'); + expect(NARRATIVE).toMatch(/压拍/); + // 标了几颗建好,主数据就得有几行 —— 逐颗对账(第一刀写成「≥1 行就算数」太松,三候选那单从缝里过去了) + expect(CMMN_XML).toContain('parts_profile_rows >= sub_eval_pn_check_exists_status_created'); + }); + + it('评估输入那张卡的**前提**写在说明书的卡骨架上(2026-08-27 e2e:两颗缺库,模型只问只建了第一颗,CN 还 absent 就把 S1 的卡发了出去 —— 发卡的授权面是调人预算,绕得过哨兵)', () => { + expect(NARRATIVE).toContain('一颗 absent 都不剩'); + expect(NARRATIVE).toMatch(/有几颗 absent 就要办几颗/); + }); + + it('发数据录入卡那一拍不许顺手写需求行(客户还没落草稿层,引用检查必拒)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0_bind')?.guide ?? ''; + expect(g).toMatch(/那一拍只发卡/); + expect(g).toContain('引用检查'); + }); + + it('absent 没清零之前不许收掉数据工单那一项(2026-08-27 e2e:建完第一颗就 finish,再想给第二颗发卡撞上「这一步已经办完收掉了」,连拒四次)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(g).toMatch(/还有没有 absent 的料号/); + expect(g).toMatch(/这一项千万别 finish/); + expect(g).toMatch(/收掉了就回不去了/); + }); + + it('参数名一律中文、与库里既有行同名(2026-08-27 e2e:模型写成 input_voltage_range,而原 PN 是「输入电压范围」—— 主键的一半对不上,27 条里 14 条判成 UNKNOWN)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(g).toMatch(/参数名一律用中文/); + // 措辞写过两遍都没拦住 → 上结构:把「同一套名字」变成基座算得出的数 + expect(CMMN_XML).toContain('parts_parameter_rows = parts_parameter_distinct_param_name * sub_eval_pn_check_exists_status_created'); + expect(g).toContain('input_voltage_range'); + expect(g).toMatch(/不是同一行/); + }); + + it('第二颗缺库的候选也要先问(每一颗都有被放弃的权利)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(g).toMatch(/这一颗也要先发一张决策卡问人/); + expect(g).toMatch(/第一颗问过了不代表第二颗也问过/); + }); + + it('created 认的是「卡交回来了」,不是「表里有行」—— 写骨架 ≠ 建好了(2026-08-27 e2e:模型铺完骨架就标 created、直接 finish,撞「从没给它发过卡」连拒五拍)', () => { + const g = ASSESSMENT_STEPS.find((s) => s.item === 'S0d_p08_master')?.guide ?? ''; + expect(g).toMatch(/写骨架 ≠ 建好了/); + expect(g).toMatch(/写骨架 → \*\*发卡\*\* → 这一拍结束 → 人交回/); + expect(g).not.toMatch(/只有它在 \\`parts\.profile\\` 里真有一行/); + }); + + it('五段进度,每段名 ≤10 字;除放行外每项恰属一段', () => { + expect(ASSESSMENT_PHASES).toHaveLength(5); + for (const p of ASSESSMENT_PHASES) expect(p.name.length, p.name).toBeLessThanOrEqual(10); + const all = ASSESSMENT_PHASES.flatMap((p) => p.items); + expect(new Set(all).size).toBe(all.length); + expect([...all].sort()).toEqual([...ITEM_IDS.filter((i) => i !== 'T_release')].sort()); + }); +}); diff --git a/activities/part-substitution-assessment/package.json b/activities/part-substitution-assessment/package.json new file mode 100644 index 0000000..362ed54 --- /dev/null +++ b/activities/part-substitution-assessment/package.json @@ -0,0 +1 @@ +{ "name": "@activities/part-substitution-assessment", "version": "0.1.0", "private": true, "type": "module", "exports": { ".": "./src/index.ts" } } diff --git a/activities/part-substitution-assessment/src/case-model.ts b/activities/part-substitution-assessment/src/case-model.ts new file mode 100644 index 0000000..6d0dd6f --- /dev/null +++ b/activities/part-substitution-assessment/src/case-model.ts @@ -0,0 +1,632 @@ +/** + * ACT-WORK-05 差异评估的案例模型 —— **双表示同版本**:CMMN XML(机器面)与案例说明书(叙事面)。 + * + * 业务出处:`docs/SS02-ACT-WORK-05-html/ACT-WORK-05-活动流程与工单说明.md`(步骤 0.5 + 5 步, + * 1 数据(条件)+ 1 执行 + 2 验收)与《SS02-SS03-SS04_Demo台账字段细化与统一方案》(字段口径)。 + * + * 文档六步收成 9 个案例模型项(0.5 那一步因 view 各不相同拆成两项 —— 引擎里剧本声明的 + * view 恒压过模型当拍报的 say.view,一个计划项只能绑一份画面,P-08 与 P-10 各自要一份可编辑的 + * 工作区件,不能共用同一个 view): + * 启动期 → S0_bind(AI:铸案号、建 P-01 V1、锁规则版本、逐个 PN 查库、写存在性核对表) + * 0.5a 等待数据(建主数据)→ S0d_p08_master(人:数据工单 P-08,件上表 1 主记录 + 表 2 标准化 + * 参数子表 `parts.parameter`;候选总数 ≥2 时缺库先决策卡; + * 都在库时哨兵不开,这一项与下一项都不会进「当下可为」) + * 0.5b 等待数据(建资料)→ S0d_p10_document(人:数据工单 P-10;都在库时同样不会进「当下可为」) + * 1 建立评估上下文 → S1_input_confirm(人:执行工单 01,评估输入清单,件上补缺口) + * 2 读取并标准化 → S2_normalize(AI:P-11 主记录骨架 + 差异明细对照行) + * 3 逐项差异评估 → S3_assess(AI + 两枚工具:四态 / 风险 / 证据 / 影响 / 推荐等级 / 验证任务) + * 4 FAE/RI 审核 → S4_review(人:验收工单 01 = 决策卡循环,驳回则 AI 改台账再发) + * 5 提交评审放行 → S5_prepare_landing(AI:analysis_status 推 fae_confirmed、回写 P-01)+ T_release(人:验收工单 02,终局放行) + * + * 五处不给 doneWhen:S0d_p08_master / S0d_p10_document(触达人)、S1(交人补缺口)、 + * S4(拍板且可循环)、T_release(签下去)。 + */ +import { D, RULE_VERSION, TOOL_COMPARE, TOOL_RECOMMEND } from './constants.ts'; + +export const CMMN_XML = ` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + update + demand_request_rows > 0 and sub_eval_pn_check_rows > 0 and sub_eval_pn_check_exists_status_absent > 0 + + + + update + parts_profile_rows > 0 and parts_profile_missing = 0 and parts_parameter_missing = 0 + + + + update + + sub_eval_pn_check_rows = count(candidateInternalPns) + 1 and sub_eval_pn_check_missing = 0 and sub_eval_pn_check_exists_status_absent = 0 and sub_eval_pn_check_exists_status_abandoned < count(candidateInternalPns) and parts_profile_missing = 0 and parts_parameter_missing = 0 and parts_document_missing = 0 and parts_profile_rows >= sub_eval_pn_check_exists_status_created and parts_document_rows >= sub_eval_pn_check_exists_status_created and parts_parameter_rows = parts_parameter_distinct_param_name * sub_eval_pn_check_exists_status_created + + + + update + input_confirmed_total > 0 and sub_eval_input_gap_rows > 0 and sub_eval_input_gap_missing = 0 + + + + update + substitution_relation_rows > 0 and substitution_relation_rows = count(candidateInternalPns) - sub_eval_pn_check_exists_status_abandoned and substitution_difference_item_rows > 0 and substitution_difference_item_distinct_substitution_relation_id = substitution_relation_rows + + + + update + substitution_difference_item_missing = 0 and substitution_relation_missing = 0 and substitution_difference_item_difference_status_match + substitution_difference_item_difference_status_mismatch + substitution_difference_item_difference_status_unknown + substitution_difference_item_difference_status_conditional = substitution_difference_item_rows and tool_part_substitution_assessment_compare_parameters_calls > 0 and tool_part_substitution_assessment_recommend_calls > 0 + + + + update + review_approved_total > 0 and substitution_difference_item_missing = 0 + + + + update + landing_prepared_total > 0 and substitution_relation_analysis_status_fae_confirmed = substitution_relation_rows and substitution_relation_missing = 0 and demand_request_missing = 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +`; + +/** + * 案例说明书 —— **只写整单一以贯之的事**(逐步做法归剧本)。 + * 卡骨架住在这里而不是剧本里(模型会压拍,压过之后只有说明书还在 —— A1/A6/I01 同一课)。 + */ +export const NARRATIVE = `§0 开案:**判断候选料号在技术上能不能替代原料号,逐参数给出可复核的差异结论,审核后落账**。 +入参: +· \`customerCode\` —— 客户编码(L-02);\`customerName\` 只在客户不在库时给。 +· \`requestDescription\` —— 客户需求原话,据它新建 P-01 需求主记录(版本 V1)。 +· \`originalInternalPn\` —— 原内部料号;\`candidateInternalPns\` —— 候选内部料号数组(≥1,逐个评估、各一条 P-11)。 +· \`datasheets\` —— 选填的真文件,基座已读成文本(每件 \`{name, text?, note}\`);有就拿它在数据工单里预填,没有就人全填。 + +**本活动只回答一件事:技术上哪种料能替**。不做数量 / 价格 / 交期 / 采购判断;客户批准状态由审批流维护,你没有那一列的写权。 + +**四项绑定后不可改**(客户 / 需求 / 原 PN / 候选数组):绑错只能退回启动人重新启动。 + +**能算的不问人也不自己判**:四态(MATCH / MISMATCH / UNKNOWN / CONDITIONAL)与推荐等级 +(推荐 / 条件推荐 / 备选 / 不推荐)全由两枚工具算 —— \`${TOOL_COMPARE}\`、\`${TOOL_RECOMMEND}\`, +一批一次。你负责对照表、证据引用、影响说明、UNKNOWN 的去向。**规则版本 \`${RULE_VERSION}\` 随每条结论落账**。 + +**UNKNOWN 是一等公民**:查不到的参数值写「未披露」,不许估、不许留空串冒充;每个 UNKNOWN 必须写去向 +(挂验证任务号或补来源动作)。硬约束 MISMATCH 不许改判,要改只能补证据后重比。 + +**存在性检查与数据工单**:启动时逐个料号在 \`parts.profile\` 里查(原 PN + 每个候选)。查无记录 = 「完全没有」, +要人从零建整条主数据(表 1 主记录 + 表 2 标准化参数子表 \`parts.parameter\`)—— 发**数据工单**(一张单:P-08 一张、P-10 一张); +PN 在库但个别字段缺 = 「有而不全」,归执行工单 01 补。**该不该问人,按候选总数判断,不是按不在库的颗数判断**: +原 PN 缺 = 硬阻塞必须建、不问;候选总数 = 1 时那一颗必须建、不问;候选总数 ≥ 2 时,每一颗不在库的候选都要先问人放弃还是创建。 +**库里都有的话这两项的入场前提本就不成立**(此单不走这条),不会出现在你的「当下可为」里,别发空单。 + +**六步走**:绑定与存在性核对 → (等待数据)→ 人补评估输入 → 标准化对照表 → 逐项评估 → 人审结论(可循环)→ 拟落账 → 人放行。 + +【本单会用到的卡,全部照下面的骨架发,别自己另编】 + +① 新客户建档(只在 \`customerCode\` 在 \`customer.profile\` 里查无时,S0_bind 里发;编码用入参给的那个,人核名): +{"kind":"entry","itemId":"S0_bind","ask":"客户 不在客户档案里,请核对建档信息后确认", + "ledger":"customer.profile","key":{"customer_code":""}, + "fields":[ + {"key":"name","label":"客户名称","value":"","required":true}, + {"key":"industry","label":"所属行业"}, + {"key":"region","label":"区域"} + ], + "basis":[{"k":"触发原因","v":"按客户编码 查客户档案,查无记录"}, + {"k":"这一单要评估的","v":"原 PN → 个候选"}, + {"k":"确认之后","v":"这家客户落进本单草稿层,评估照常往下走"}]} +**\`basis\` 这三行必须给**:不给的话基座会兜上「这一步 / 当下可为 / 目标缺口」那几行内部家具 —— +把九个计划项的全名摆到人脸上,他一个字也用不上(2026-08-27 实测)。 +人确认那一下基座已把这一行落进草稿层,**你不许再 write 一遍 customer.profile**。 + +② 候选不在库、且候选总数 ≥2 时,一颗一张决策卡(按候选数组顺序,一次只发一张;候选总数 = 1 时不问、直接建): +{"kind":"decide","itemId":"S0d_p08_master", + "ask":"候选 在芯片主数据里查无记录。是从零建它的主数据(派数据工单),还是本轮放弃这颗候选?", + "options":[{"value":"create","label":"创建主数据(派数据工单)","recommended":true}, + {"value":"abandon","label":"放弃这颗候选"}],"allowCustom":true} +\`value\` 只有 \`"create"\` / \`"abandon"\` / \`"custom:"\` 开头三种:\`"custom:"\` 开头按放弃处理、\`note\` 就是放弃原因; +点了 \`"abandon"\` 没写原因,\`abandon_reason\` 写「负责人本轮放弃(未注明原因)」。 + +③ 数据工单 · P-08(所有要建的料号一起,一张单;零输入,填报全在工作区的件上)—— +**发这张卡之前,\`parts.profile\` 与 \`parts.parameter\` 必须先有骨架行**(名单里每颗料各一行 + 它的参数各一行)。 +不管这一拍是不是顺手把上一步收掉的(压拍常发生,那时这一步的剧本还没摊开),写骨架与发卡都得在同一串里,顺序不能反 —— +件上一行都没有的话,人打开是一张空表、什么也补不了,而这一单的主数据从头到尾不会存在 +(实测走到 S2 才被引用检查拦下,那时两张数据工单都已经「办完」了) +{"kind":"human","itemId":"S0d_p08_master","workOrder":"execution","card":{ + "title":"数据工单 · 芯片主数据创建(P-08):<料号列表,顿号分隔>", + "ask":"这些料号在芯片主数据里查无记录,请在工作区的件上把整条记录建齐(一颗一行,可加行)。", + "steps":["表 1 每一行:品牌、规格描述、封装、生命周期状态为必填,缺一格确认不了", + "表 2 一行一个参数:所属料号、参数名、值、单位、约束(硬/软)必填,说明是只读注释;原厂未披露的值写「未披露」,它会进入 UNKNOWN 并挂验证任务", + "有 datasheet 的把引用与版本一起填(成对);制造商与品牌不一致时分开写", + "改完保存,回这张卡确认 —— 确认后这批主数据即入库,活动从等待数据唤醒"], + "standard":"每颗料号表 1 一行,必填列全齐;表 2 至少含输入电压范围 / 输出电压 / 输出电流 / 工作温度 / 封装相关的硬约束项各一行。", + "gateLedgers":["parts.profile","parts.parameter"], + "basis":[{"k":"触发原因","v":"按 internal_pn 查 P-08 查无记录(完全没有,不是字段缺失)"}, + {"k":"AI 预填","v":"<有 datasheet 就写「已按 datasheet 预填 N 项,请核对」,没有写「未上传 datasheet,请全填」>"}]}} +**\`gateLedgers\` 必须给**:这是零输入卡,基座不知道这一张要人补哪几张表 —— +不给它就回落到必交付物那几张(与这张卡无关),于是件上红带点着「缺品牌名称」而提交钮照样绿, +空手交卷一路放行(2026-08-27 实测)。给了之后,闸与红带、放行门读的是同一个数。 + +④ 数据工单 · P-10(同一批料号的资料记录,一张单;在 P-08 那张确认之后再发)—— +**与③同一条:发这张卡之前 \`parts.document\` 必须先有骨架行**(名单里每颗料至少一行, +key 是 {internal_pn, doc_seq:"01"});一行都没有的话人打开是空表、什么也补不了, +提交闸会如实拦住(「这一单还一行都没有」),这一单就卡在这儿了(2026-08-27 实测)。 +{"kind":"human","itemId":"S0d_p10_document","workOrder":"execution","card":{ + "title":"数据工单 · 原厂技术资料创建(P-10):<料号列表>", + "ask":"请把这些料号的 datasheet / 承诺函等资料记录补进原厂技术资料库(一份资料一行,可加行)。", + "steps":["资料类型、标题、版本、文件链接、资料状态为必填;证据定位写页码或章节,差异评估的证据引用会指向它", + "同一料号多份资料就多加几行,序号 01/02… 自己续", + "改完保存,回这张卡确认"], + "standard":"每颗料号至少一行 datasheet 记录,必填列全齐。", + "gateLedgers":["parts.document"], + "basis":[{"k":"触发原因","v":"按 internal_pn 查 P-10 查无记录"}]}} + +⑤ 执行工单 01 · 评估输入与资料补齐确认(S1_input_confirm;零输入)—— +**发它的前提:所有料号都已落定** —— \`${D}.pn_check\` 里**一颗 absent 都不剩**(每颗要么 found、要么经数据工单 created、 +要么人点了放弃 abandoned),且建过的那几颗在 \`parts.profile\` 里真有行。还有 absent 就**回去把它们办完** +(候选总数 ≥2 的逐颗发决策卡问、原 PN 与独苗候选直接建),别先发这张卡: +硬发出去人也补不成 —— 后面写替代关系时会被引用检查逐颗拦下,而那时数据工单都已经「办完」了(2026-08-27 实测两轮)。 +**有几颗 absent 就要办几颗**,办完第一颗别忘了还有第二颗。 +**发这张卡之前,\`${D}.input_gap\` 必须先有行**:清单为空的卡就是让人对着一张空表签字,他补不了任何东西。 +不管这一拍是不是顺手把上一步收掉的(压拍常发生,那时 S1 的剧本还没摊开),写清单与发卡都得在同一串里,顺序不能反: +已绑定四项(customer / request / original_pn / candidate_N,status="ok")、待补两项(application_scenario / bom_position,status="gap")、 +默认三项(substitution_type / rule_version / owner,status="default")、每颗候选的「未披露」参数各一行(status="gap")、原 PN 资料版本(status="ok"); +逐列口径见这一步的剧本。 +{"kind":"human","itemId":"S1_input_confirm","workOrder":"execution","card":{ + "gateLedgers":["${D}.input_gap"], + "title":"评估输入与资料补齐确认:<原 PN> → 个候选", + "ask":"启动绑定的四项已锁定。请在工作区的件上补齐「待补 / 待确认」行的补充内容,默认值可改可确认。", + "steps":["应用场景、BOM 位是启动时未收的:必须补(写在「补充内容」列)", + "原厂未披露的参数(如使能阈值)补不到就写「挂验证任务」或「留 UNKNOWN」—— 补不了也是合法答案,不拦流程", + "替代类型 / 规则版本 / 负责人期限三行是系统默认,可改可不改", + "加一行 = 补充 AI 没列出的资料项;删一行 = 该项不适用;已绑定的四项不可改", + "改完保存,回这张卡提交"], + "standard":"每一条「待补」行的补充内容都有;补不了的写明理由。", + "basis":[{"k":"已绑定","v":"客户 · 需求 V1 · 原 PN <原 PN> · 候选 颗"}, + {"k":"缺口","v":" 项待补 / 待确认"}]}} + +⑥ 验收工单 01 · 差异评估结论审核(S4_review;决策卡循环,不是终局验收)—— 发之前先在轨迹里找有没有已答过、还没处理的 \`[card-reply]\`: +· \`value\` 是 \`"approve"\` → 写 \`${D}.verdict.review_approved_total = 1\`,finish 这一项,别再发卡; +· \`value\` 是 \`"reject"\` 或以 \`"custom:"\` 开头 → 都算驳回:\`"reject"\` 没写意见,**不许再发卡追问**;\`"custom:"\` 的 \`note\` 就是他的意见, + 按意见改 \`substitution.difference_item\` / \`substitution.relation\`(同 PK 覆盖写,不开新行),意见要挂验证的写一行 \`validation.record\`, + 然后**换一种问法**再发一张(措辞不换会被当成同一张卡静默吞掉); +· 没有 → 才发第一张: +{"kind":"decide","itemId":"S4_review","allowCustom":true, + "ask":"差异评估结论已算出: 个候选、共 条参数比对(MATCH a / MISMATCH b / UNKNOWN c / CONDITIONAL d),推荐等级 <逐候选一句>。请审核。", + "options":[{"value":"approve","label":"通过","recommended":true}, + {"value":"reject","label":"驳回(不写具体意见)"}]} +三个 \`value\` 只有 \`"approve"\` / \`"reject"\` / \`"custom:"\` 开头三种,别造第四种。 + +【一路上要说话】每一拍带一句 say,说业务的话:查了几颗料、缺几颗、对照了几项、四态各几条、推荐等级各是什么。到了要找人的那一拍,先说清这一轮办完了什么、为什么现在需要他。用件上那三个词(必填 / 建议 / 选填)说缺口,只说事实。 + +【怎么把一项干完 · 一拍连做】write 和 tool 都不会自动收步 —— 做完用 finish 宣告(有 doneWhen 的项引擎自己收)。 +动作排进同一拍的 actions 串一口气给;只有发卡 / 提交(挂起)必须停拍;tool 之后同拍其余动作作废。 +**常路 9–12 拍收口**(候选缺库那条路多两张数据工单、多两拍)。 + +§Z 结案:FAE/RI 在验收单上签字,系统把草稿合并进 P-08 / P-10 / P-01 / P-11 / P-06 正式版并发射 \`assessment-released\` 口。`; + +/** + * 步骤剧本 —— 一个计划项一条;`doneWhen` 是「成果已存在」的判据,不是「该不该做」。 + * 五处不给 doneWhen:S0d_p08_master / S0d_p10_document(发数据工单触达人)、S1(交人补缺口)、 + * S4(拍板且循环)、T_release(签下去)。 + */ +export const ASSESSMENT_STEPS = [ + { + item: 'S0_bind', + intent: '铸案号、建需求 V1、锁规则版本、逐个料号查库、写存在性核对表', + writes: ['demand.request', `${D}.pn_check`, `${D}.verdict`, 'customer.profile'], + reads: ['customerCode', 'customerName', 'requestDescription', 'originalInternalPn', 'candidateInternalPns', 'datasheets', 'case:openedAt', 'customer.profile', 'parts.profile'], + view: 'eval-input-list', + tools: [], + /* + * 「该有几行」也进判据:原 PN + 每个候选各一行核对(count(candidateInternalPns) + 1); + * 少一行 = 一颗料从这一单里凭空消失。count() 对未绑定名回 1 —— candidateInternalPns 是必填入参,恒绑定。 + */ + doneWhen: + `demand_request_rows > 0 and demand_request_missing = 0 and ${D}_verdict_rows > 0 and ` + + `${D}_pn_check_rows = count(candidateInternalPns) + 1 and ${D}_pn_check_missing = 0`, + guide: `第一件事:**把这一单的上下文立起来**,一拍连做(客户不在库时多一张录入卡、多一拍)。 + +【先铸案号】\`eval_ref = 'W05-' + case:openedAt 按 YYYYMMDDHHmmss 格式化\`(\`case:openedAt\` 形如 "2026-08-26 21:03:15",去掉分隔符即得); +\`request_id = 'REQ-' + 同一串数字\`;\`input_snapshot_ref = 'SNAP-' + eval_ref\`。**不许从正式表里别单的案号里挑**,整单只有这一个 eval_ref。 + +【客户在不在库】在 \`customer.profile\` 里找 \`customerCode\`:在 → 直接用;不在 → 照说明书①发数据录入卡(名字用 \`customerName\`), +发完这一拍结束;人确认后这家客户就在草稿层里了,下一拍接着做。**客户不在库也不许自己 write customer.profile**。 +**那一拍只发卡,别顺手写 \`demand.request\`** —— 需求行的客户编码有引用检查(客户还没落草稿层,写下去当场被拒); +等人确认完,下一拍再写需求行与核对表,一次写齐。 + +【写 \`demand.request\` 一行(V1)】request_id、customer_code(= customerCode)、requirement_version = "V1"、request_type = "技术需求"、 +request_description(入参原话,不改写)、input_snapshot_ref、original_internal_pn、request_status = "pending"、current_activity = "ACT-WORK-05"、 +current_stage = "assessing"。application_scenario / bom_position **这一步不写**(启动时未收,S1 由人补)。 + +【逐个料号查库,写 \`${D}.pn_check\`】\`parts.profile\` 整表在你的作用域里,按 \`internal_pn\` 逐个核对:原 PN 一行(role = "original"), +每个候选一行(role = "candidate");在 → exists_status = "found" **且 \`found_pn_ref\` 填你在 \`parts.profile\` 里真找到的那一行的 internal_pn** +(与本行 internal_pn 一模一样);不在 → exists_status = "absent"、\`found_pn_ref\` 留空(**等数据工单确认后再改成 created**)。 +一颗都不能少:数组里点了几颗候选,就写几行 + 原 PN 一行。note 选填(如「PCN 转 NRND」)。 + +**「在库」这句话基座要拿去查**:\`found_pn_ref\` 声明了引用 \`parts.profile.internal_pn\`,写下去那一刻基座就去主数据里查, +**查无此值当场拒**。被拒不是让你换个号去顶 —— 那说明这颗料真的不在库,把这一行改成 absent(依据留空),数据工单那一步的门自己会开。 +判 found 却填不出依据也走不动:这一步的收步条件里有「核对表不缺必填」。**别凭料号长得像就判在库,名单里没有就是没有。** + +【写 \`${D}.verdict\` 一行】eval_ref、request_id、rule_version = "${RULE_VERSION}"、original_internal_pn、candidate_total = 候选数组长度。 + +写完这一项就结束。有 absent 的 → 下一项是 S0d_p08_master(数据工单),照常往下办。 +**都在库的话你什么都不用做** —— 数据工单那两项的入场前提本就不成立,它们不会出现在你的「当下可为」里, +下一拍你会直接看到「评估输入与资料补齐确认」那一步。**任何时候都不要对计划项用 \`disable\`**: +本引擎里 \`Disabled\` 只能从 \`Enabled\` 来,而普通计划项一直停在 \`Available\`,disable 一定被拒。`, + }, + { + item: 'S0d_p08_master', + intent: '料号不在库:派 P-08 数据工单让人从零建芯片主数据 + 标准化参数子表;候选总数 ≥2 才逐颗问放弃还是创建', + writes: ['parts.profile', 'parts.parameter', 'parts.document', `${D}.pn_check`], + reads: [`${D}.pn_check`, 'candidateInternalPns', 'originalInternalPn', 'datasheets', 'parts.profile', 'parts.parameter', 'parts.document'], + view: 'p08-master-create', + tools: [], + /* 触达人,不给 doneWhen;人工激活:发卡就算启动 */ + guide: `这一项只在 \`${D}.pn_check\` 里有 absent 行时走 —— 都在库时入场前提本就不成立,这一项与下一项 S0d_p10_document 都不会进你的「当下可为」。**先分岔,再动作**: + +【先数两个数,再分岔】(先看轨迹:这一项里已经发过哪些卡、人答了什么,【当前这一步】下面那行引擎事实说得清楚) +· **候选总数**:入参 \`candidateInternalPns\` 的长度(\`${D}.pn_check\` 里 role = "candidate" 的行数也是它,不随本单进展变化); +· **不在库的候选数**:\`${D}.pn_check\` 里 role = "candidate" 且 exists_status = "absent" 的行数(这个数会随着人放弃/创建而变小)。 +**这里要分开答两个问题,别混成一个**: + +**问题一 · 建哪几颗?** 名单 = \`${D}.pn_check\` 里 **exists_status = "absent" 的每一行**,不管它是原 PN 还是候选。 +**exists_status = "found" 的一行都不建** —— 那几颗的主数据本来就在库里,给它们派数据工单等于让人把已有的东西再填一遍, +而真正缺的那颗还是没人建、单子照样卡死。名单为空(一行 absent 都没有)这一项根本不会出现在你的「当下可为」里。 + +**问题二 · 建之前要不要先问人?** 只有 **absent 的候选**才谈得上问,**看的是候选总数,不是不在库的颗数** +——**「不在库的只有一颗」不是跳过决策卡的理由**: +· 原 PN absent → **硬阻塞**,不问人,直接进名单(它是评估基准,没有它整单无从谈起); +· **候选总数 = 1** → 那一颗候选**如果是 absent** 就不许放弃、不问人,直接进名单(候选是 found 的话它压根不在名单里,没有可问的); +· **候选总数 ≥ 2** → **每一颗 absent 的候选都要先发一张决策卡问人**(一次一张,按候选数组顺序;哪怕这一单不在库的候选只有一颗, + 只要候选总数 ≥ 2 就要问)照说明书②;人选 "abandon"/"custom:" 的,把那一行 \`${D}.pn_check\` 改成 + exists_status = "abandoned" + abandon_reason(同 PK 覆盖写),这颗不再评估;选 "create" 的进「建」的名单。 +**至少留一颗候选**:放弃到只剩最后一颗还是 absent 的候选时,那一颗按「候选总数 = 1」办 —— 不再发决策卡问,直接进「建」的名单 +(候选全被放弃,存在性核对永远凑不齐、单子会死锁,这一条就是防它)。 +**别把同一颗候选问两遍**:决策卡答过就按答案办。 + +【「建」的名单定了 → 写骨架行,发 P-08 数据工单(一张单,件上两张表)】 +1. 给名单里每颗料写一行 \`parts.profile\` 骨架(表 1):key {internal_pn},patch 只带你确有依据的列 —— 有 \`datasheets[].text\` 就从里面读 + brand_name / specification_description / package / lifecycle_status(active/nrnd/eol/discontinued/risk 之一)/ datasheet_ref + datasheet_version; + 没有 datasheet 就只写 internal_pn 这一列(其余留给人填,**别编**)。 +2. 同一拍给每颗料写标准化参数集骨架(表 2,\`parts.parameter\`,一行一参数): + **参数名一律用中文,与库里既有料号的那几行同名**(输入电压范围 / 输出电压 / 输出电流 / 开关频率 / + 静态电流 / 工作温度 / 使能阈值…)—— \`param_name\` 是主键的一半,写成 \`input_voltage_range\` + 与写成「输入电压范围」**不是同一行**:原 PN 那边是中文、候选这边是英文,比对时两套名字对不上, + 逐条判成 UNKNOWN,结论就废了(2026-08-27 实测:27 条里 14 条 UNKNOWN)。 + 封装、工艺、生命周期这些**不是参数**,它们在表 1,别往表 2 里塞。 + **建几颗料就用同一套名字**:门上有一条对账 —— 参数行数 = 不同参数名数 × 建过的料数, + 只有每颗料的名字集合一模一样时才成立;混着写(这颗中文那颗英文、或同一颗写两套)这一步就过不去。有 \`datasheets[].text\` 就从里面读出典型参数 + (如输入电压范围 / 输出电压 / 输出电流 / 开关频率 / 静态电流 / 工作温度 / 使能阈值等,按品类而定)各写一行, + key {internal_pn, param_name},patch 带 param_value / param_unit / constraint_type(hard/soft)/ param_note(一句话说清这项为什么要卡, + 如「须覆盖客户输入上限」);原厂没写的值写「未披露」(它会进入 UNKNOWN 并挂验证任务)。没有 datasheet 就只写 + internal_pn + param_name 骨架(把你判断这颗料该评估的参数名列出来,**param_value 留空给人填,别编**)。 +3. 同一拍**给名单里每一颗料各写一行** \`parts.document\` 骨架(两颗就两行,别只写一行 —— + 门上有一条对账:建好几颗就得有几行资料记录;少一行,那颗料的资料工单人打开是空的):key {internal_pn, doc_seq: "01"},patch {document_type: "datasheet", document_status: "pending", + brand_name 有就写}(这一行是骨架,下一项 S0d_p10_document 会把它填成正式记录)。 +4. 同一拍发说明书③那张 P-08 数据工单(title 里列全料号),发完这一拍结束(挂起)。 + +**\`created\` 认的是「那张卡交回来了」,不是「表里有行」** —— **写骨架 ≠ 建好了**: +骨架是**你**铺的(只有料号和参数名),值是**人**在件上填的。骨架一铺就把 pn_check 改成 created, +等于替人宣布他已经办完了:接着你会以为数据工单收工、去 finish 这一项,而卡根本没发出去 —— +撞上「这一单里从没给它发过卡」,连撞五拍熔断(2026-08-27 实测,整单白跑)。 +**顺序只有一个**:写骨架 → **发卡** → 这一拍结束 → 人交回 → 这时才把那几颗改成 created。 +门上还有一条逐颗对账(建好几颗就得有几行主数据、几行资料),标了却没建,这一步照样过不去。 + +【P-08 那张确认回来了】**先看名单里还有没有 absent 的料号**(\`${D}.pn_check\` 现读): +· **还有** → **这一项千万别 finish**。先回到上面【问题二】那一档:候选总数 ≥2 的话, + **这一颗也要先发一张决策卡问人**(照说明书②,人选 create 才建 —— 每一颗 absent 的候选都有被放弃的权利, + 第一颗问过了不代表第二颗也问过);人选 create 之后再把它的骨架写好(profile + parameter,有 datasheet 就预填), + 发一张 P-08 卡(标题带那一颗的料号)—— 同一个计划项可以先后发好几张卡,一颗一张也行。 + 原 PN 与「候选总数 = 1」那两档不问,直接建。 + **收掉了就回不去了**:这一项一旦 Completed,再想给它挂第二张卡会被拒「这一步已经办完收掉了」, + 而那颗料从此没人建,后面写替代关系时被引用检查逐颗拦下(2026-08-27 实测,一单连拒四次)。 +· **一颗都不剩了** → 才走下面这两步。 + +这一拍的动作串**恰好两个,顺序不能反**: +① 先 \`finish S0d_p08_master\` —— **必须先把这一项收掉**。不收掉,引擎挑工作区画面时按 +「当下还没干完的第一步」取 view,S0d_p08_master 只要还 Active,画面就一直停在 +\`p08-master-create\`(P-08 那两张表);下一拍就算发出了 P-10 的卡,人的工作区也看不见 +P-10 的资料表,一格都填不了,提交闸必然拦死。 +② 再照说明书④发 P-10 数据工单 —— 下一项是 S0d_p10_document,同一批料号接着补资料记录。 + +【这张卡一单只发一次】人交回来之后不许再发;答复里没有值(空 values)也算答过 —— 人在件上填的东西已经落草稿层。`, + }, + { + item: 'S0d_p10_document', + intent: '料号不在库:派 P-10 数据工单让人从零建原厂技术资料', + writes: ['parts.document', `${D}.pn_check`], + reads: [`${D}.pn_check`, 'parts.profile', 'parts.document'], + view: 'p10-document-create', + tools: [], + /* 触达人,不给 doneWhen;人工激活:发卡就算启动 */ + guide: `这一项只在 \`${D}.pn_check\` 里有 absent 行时走(要走到这一步,S0d_p08_master 必然已经收完);都在库时入场前提本就不成立, +这一项与 S0d_p08_master 都不会进你的「当下可为」。**进到这一项时,S0d_p08_master 应当已经收掉了;若它还开着(Active), +先 \`finish S0d_p08_master\` 再发这张卡** —— 它没收掉,画面会一直停在 P-08 那两张表,人拿到 P-10 的卡也看不见资料表。 + +【发 P-10 数据工单】「建」的名单就是 \`${D}.pn_check\` 里仍是 exists_status = "absent" 的那几行(候选总数 ≥2 时被放弃的那些, +S0d_p08_master 那一步已经把它们改成 "abandoned",不在这份名单里)。同一拍照说明书④发那张 P-10 数据工单(title 里列全料号,只发一次), +发完这一拍结束(挂起)。 + +【P-10 那张确认回来了】把名单里每颗料的 \`${D}.pn_check\` 改成 exists_status = "created"(同 PK 覆盖写),然后 finish 这一项。 +这时 S1_input_confirm 的入场前提(全部料号落定、本单建的主数据不缺必填)自己就成立了 —— 缺必填由提交闸兜着,卡回来时一定是齐的。 + +【这张卡一单只发一次】人交回来之后不许再发;答复里没有值(空 values)也算答过 —— 人在件上填的东西已经落草稿层。`, + }, + { + item: 'S1_input_confirm', + intent: '评估输入清单:绑定四项只读核对,缺口行交 PW 在件上补', + writes: [`${D}.input_gap`, `${D}.verdict`, 'demand.request'], + reads: [`${D}.input_gap`, `${D}.pn_check`, 'demand.request', 'parts.profile', 'parts.parameter', 'parts.document', 'candidateInternalPns', 'originalInternalPn'], + view: 'eval-input-list', + tools: [], + /* 交人补缺口,不给 doneWhen;人工激活:发卡就算启动 */ + guide: `料号全部落定了,**该 PW 补评估输入了** —— 这是本活动唯一的执行工单,零输入。**先分岔**:【当前这一步】那行引擎事实说 +「从没给它发过卡」→ 走【发卡】;说「人已经被问过了」→ 走【收口】。 + +【发卡】先把评估输入清单写下来(\`${D}.input_gap\`,一行一项,item_key 用英文短键,input_item 用人读名),一拍连做: +· 已绑定四项(status = "ok",detail 写绑定值,origin = "ai"):item_key = customer / request / original_pn / candidates + (候选多颗就 candidate_1、candidate_2… 一颗一行,detail 写料号与在库状态); +· 待补两项(status = "gap",detail 写「启动时未收」):application_scenario「应用场景」(source_ledger = "P-01")、bom_position「BOM 位」(source_ledger = "P-09"); +· 默认可改三项(status = "default",detail 写默认值):substitution_type「替代类型」= "Pin-to-Pin"、rule_version「规则版本」= "${RULE_VERSION}"、owner「负责人 / 期限」= "按客户线默认 · 1 个工作日"; +· 待确认(status = "gap"):逐颗候选看它名下 \`parts.parameter\` 的那几行,param_value 是「未披露」的各一行(item_key = unknown_<料号>_<序号>, + input_item 如「XL2596S-5.0 使能阈值」,source_ledger = "P-08",detail 写「原厂未披露(有而不全)」); +· 齐备项(status = "ok"):原 PN 资料版本(source_ledger = "P-10",detail 写 datasheet 版本)。 +写完同一拍照说明书⑤发执行工单,发完这一拍结束(挂起)。 + +【收口】人交回之后只做三件事,然后 finish: +① 读 \`${D}.input_gap\` 现值:把 application_scenario / bom_position 两行的 supplement 抄进 \`demand.request\`(同 PK 覆盖写这两列; + supplement 写「补不了」「UNKNOWN」之类的,这两列不写);人加的行(origin = "human-added")同等作数,写进 technical_constraints 一句汇总。 +② 写 \`${D}.verdict.input_confirmed_total = 1\`。 +③ finish 这一项。**别在这一拍做对照表** —— 那是下一步的活。 + +【这张卡一单只发一次】人交回来之后不许再发;缺必填有提交闸兜着。`, + }, + { + item: 'S2_normalize', + intent: '读取并标准化:每个未放弃的候选一条 P-11 主记录骨架 + 逐参数对照行', + writes: ['substitution.relation', 'substitution.difference_item'], + reads: ['parts.profile', 'parts.parameter', 'parts.document', 'demand.request', `${D}.pn_check`, `${D}.input_gap`, `${D}.verdict`, 'candidateInternalPns', 'originalInternalPn'], + view: 'difference-review', + tools: [], + doneWhen: + `substitution_relation_rows > 0 and substitution_relation_rows = count(candidateInternalPns) - ${D}_pn_check_exists_status_abandoned and ` + + 'substitution_difference_item_rows > 0 and substitution_difference_item_distinct_substitution_relation_id = substitution_relation_rows', + guide: `输入齐了,**把多来源资料整成可比对的对照表**,一拍连做(先写关系,再写明细 —— 明细引用关系 id,顺序反了会被拒)。 + +【每个未放弃的候选一条 \`substitution.relation\` 骨架】(\`${D}.pn_check\` 里 exists_status 是 found / created 的候选;abandoned 的不写) +substitution_relation_id = "REL-<案号数字串>-01/02…"(按候选数组顺序)、eval_ref、request_id、original_internal_pn、candidate_internal_pn、 +substitution_type = "pin_to_pin"(人在评估输入清单里改了替代类型就照改:功能替代 → functional、参数替代 → parametric)、 +analysis_status = "ai_draft"、rule_version = "${RULE_VERSION}"、bom_position(照 demand.request 现值抄,没有不写)。 +recommendation_level / recommendation_reason / difference_summary / risk_level **这一步一格都不写**(S3 的活)。 + +【每条关系逐参数写 \`substitution.difference_item\` 对照行】骨架按**原 PN 在 \`parts.parameter\` 里的那几行**(它是独立子表,一行一参数, +按 internal_pn 归属):原 PN 有的每个参数一行 —— difference_item_id = "<关系id>-P01/P02…"、parameter_name(取原 PN 那一行的 param_name)、 +original_value(取原 PN 那一行的 param_value)、candidate_value(候选在 \`parts.parameter\` 里同 param_name 那一行的 param_value; +候选没有这个参数 → 写「未披露」)、parameter_unit(以原 PN 那一行的 param_unit 为准;候选单位不同先换算, +换算不了原值照写、evidence_ref 里注明)、constraint_type(取原 PN 那一行的 constraint_type;没标的按口径:封装 / 工艺 / 电压 / 电流 / 温度 / 阈值 hard,其余 soft)、 +rule_version = "${RULE_VERSION}"、evidence_ref(值从哪来:「P-08 · P-10 <版本>」;本单数据工单建的料号写「人工录入 · 数据工单 · P-08」)。 +另加两行**封装**与**生命周期**(constraint_type = hard / soft,值分别取 \`package\` 与 \`lifecycle_status\`)。 +difference_status / compare_result / risk_level / impact_statement / unknown_disposition **这一步不写**。 + +**缺参数不得伪造**:候选那一侧查不到就写「未披露」。写完引擎自己收这一项(每条关系都有明细行才算)。`, + }, + { + item: 'S3_assess', + intent: '逐项差异评估:四态与推荐等级由工具算,证据 / 影响 / UNKNOWN 去向由你写', + writes: ['substitution.relation', 'substitution.difference_item', 'validation.record', `${D}.verdict`], + reads: ['substitution.relation', 'substitution.difference_item', 'demand.request', `${D}.input_gap`, `${D}.verdict`], + view: 'difference-review', + tools: [TOOL_COMPARE, TOOL_RECOMMEND], + doneWhen: + 'substitution_difference_item_missing = 0 and substitution_relation_missing = 0 and ' + + 'substitution_difference_item_difference_status_match + substitution_difference_item_difference_status_mismatch + ' + + 'substitution_difference_item_difference_status_unknown + substitution_difference_item_difference_status_conditional = substitution_difference_item_rows and ' + + 'tool_part_substitution_assessment_compare_parameters_calls > 0 and tool_part_substitution_assessment_recommend_calls > 0', + guide: `对照表铺好了,**固定三拍**:比对 → 定级 → 写盘。**工具调用后同拍其余动作作废**,别把工具和写台账串在一起;两枚工具各只调一次。 + +【第一拍:只调 \`${TOOL_COMPARE}\`,别的什么都不写】把**全部**关系一次打包: +{"candidates":[{"candidateInternalPn":"<候选>","pairs":[{"parameterName":"输入电压范围","originalValue":"4.5~40","candidateValue":"4.5~32", + "unit":"V","constraintType":"hard","requirement":">= 40","evidenceRef":"P-08 · P-10 Rev H"}, …]}, …]} +· pairs 逐条照 \`substitution.difference_item\` 抄(parameterName / originalValue / candidateValue / unit / constraintType / evidenceRef); +· **客户在应用场景里给了边界的参数才写 requirement**(如「输入上限 40V」→ 输入电压范围那一对写 ">= 40";「工业温域」→ 工作温度写 "-40~85"); +· 每一对都带 evidenceRef —— 硬约束没有证据引用工具不判 MATCH,那正是要的。 +调完这一拍结束。 + +【第二拍:只调 \`${TOOL_RECOMMEND}\`,别的什么都不做】把第一拍出参里每个候选的 counts 原样打包传进去:{"candidates":[{"candidateInternalPn":"…","counts":{…}}, …]}。调完这一拍结束。 +**推荐等级只能由它算**——你自己填一个进 \`substitution.relation.recommendation_level\`,数据面看着像对的,机制上却是你拍的; +而且这一步的收步判据数着这枚工具的调用次数,不调它这一步永远收不掉。 + +【第三拍:写盘前先自检,再一拍连做写盘,一次都不再调工具】 +动手写之前,先在局面的基座读数里找这两个数:\`tool_part_substitution_assessment_compare_parameters_calls\` 与 +\`tool_part_substitution_assessment_recommend_calls\`。**两个都必须 > 0 才能写盘**。若 \`recommend\` 那个还是 0, +说明第二拍没调成——**回去调它**(入参就是第一拍出参里每个候选的 counts),不要往下写、更不要自己拍推荐等级。 +这一步的收步判据里就有这两个数,**不调够,写多少行都收不了步**。 +① 逐条 \`substitution.difference_item\` 同 PK 覆盖写:difference_status / compare_result / risk_level 照第一拍出参**一字不改**; + impact_statement(MATCH 写「无」;其余说清对应用 / 验证 / 报价的影响,如「输入上限 32V < 客户 40V,不能上板」); + difference_status = unknown 的行**必须**写 unknown_disposition(「挂验证任务 VAL-<案号数字串>-01:实测使能阈值」或「向原厂补来源」);confidence(0~1)。 +② 每个 UNKNOWN 写一行 \`validation.record\`:validation_id = "VAL-<案号数字串>-01/02…"、request_id、validation_internal_pn(候选)、 + validation_type = "pin_to_pin"、validation_status = "not_started"、next_validation_action(要测什么、什么条件)、test_condition。 +③ 逐条 \`substitution.relation\` 同 PK 覆盖写:recommendation_level / risk_level 照第二拍出参、recommendation_reason(工具 reason 扩写成人话, + 引具体参数)、difference_summary(「7 项比对:4 MATCH / 1 MISMATCH / 1 UNKNOWN / 1 CONDITIONAL」)、analysis_report_ref = "RPT-<案号数字串>"、 + confidence_score(取该候选各行 confidence 的最小值);recommendation_level = conditional 的行**必须**写 verification_requirement(列出 VAL 号)、validation_id。 +④ \`${D}.verdict\` 同 PK 覆盖写:relation_total、recommended_total / conditional_total / alternate_total / not_recommended_total(数关系表)。 +写完引擎自己收这一项;下一项是审核(S4),**这一拍不要发卡**。 + +**不许把工具的结论改成别的**:不推荐就是不推荐;要改只能补证据后重比。`, + }, + { + item: 'S4_review', + intent: '差异评估结论审核:决策卡循环,通过或驳回 + AI 按意见改台账重发', + writes: ['substitution.relation', 'substitution.difference_item', 'validation.record', `${D}.verdict`], + reads: ['substitution.relation', 'substitution.difference_item', 'validation.record', `${D}.verdict`], + view: 'difference-review', + tools: [], + /* 要人拍板,且这一项内部可能循环 —— 不给 doneWhen */ + guide: `结论算出来了,**该 FAE/RI 审核了** —— 这是验收工单 01,走决策卡(不是终局验收)。**先分岔,再动作**: +轨迹里找这一项已答过、还没处理的 [card-reply]: +· 没有 → 照说明书⑥发第一张决策卡(ask 里把候选数、比对条数、四态各几条、逐候选推荐等级说全),发完这一拍结束。 +· "approve" → 写 \`${D}.verdict.review_approved_total = 1\`,finish 这一项。别再发卡。 +· "reject" / "custom:…" → **驳回**。按意见改台账(同 PK 覆盖写,不开新行、不改行数): + · 意见点名某个参数 → 改那一行 \`substitution.difference_item\` 的 impact_statement / unknown_disposition / evidence_ref;要挂验证的补一行 \`validation.record\`; + · 意见说推荐理由站不住 → 改 \`substitution.relation.recommendation_reason\`(等级不许改 —— 那是工具算的;要改先回 S3 补证据重比,本活动不回头,写清楚为什么维持); + · 没写具体意见("reject")→ 自己挑最站不住的一处改实(证据最含糊的那条 evidence_ref、去向最空的那条 unknown_disposition),**至少改对一处**; + 然后**换一种问法**再发一张决策卡(把改了什么写进 ask),发完结束。 +**基座对着字面比对意见与草稿**:观察里点名了哪一行,就改那一行,不挪到别的行头上。`, + }, + { + item: 'S5_prepare_landing', + intent: '拟落账:P-11 分析状态推到 FAE 确认,回写 P-01 五项', + writes: ['substitution.relation', 'demand.request', `${D}.verdict`], + reads: ['substitution.relation', 'substitution.difference_item', 'validation.record', 'demand.request', `${D}.verdict`], + view: 'landing-confirm', + tools: [], + doneWhen: + 'landing_prepared_total > 0 and substitution_relation_analysis_status_fae_confirmed = substitution_relation_rows and ' + + 'substitution_relation_missing = 0 and demand_request_missing = 0', + guide: `审核通过了,**把拟落账的内容备好**,一拍连做: +① 每条 \`substitution.relation\` 同 PK 覆盖写 analysis_status = "fae_confirmed"(只推分析层;客户批准状态你没有写权,别碰)。 +② \`demand.request\` 同 PK 覆盖写五项 + 状态:risk_level(取各候选 risk_level 里最高的一档)、verification_requirement(把所有 VAL 号与要测什么列全; + 没有 UNKNOWN 写「无需验证」)、output_ref = "RPT-<案号数字串>"、next_action = "提交 ACT-GATE-03 评审放行"、current_activity = "ACT-WORK-05"、 + current_stage = "gate03"、request_status = "responded"。 +③ \`${D}.verdict\` 同 PK 覆盖写:landing_prepared_total = 1、summary 一句人话(几个候选各什么等级、挂了几个验证任务)。 +写完引擎自己收这一项,下一项是放行。**这一拍不要 submit**。`, + }, + { + item: 'T_release', + intent: '拟落账内容已备好,提交 ACT-GATE-03 交 FAE/RI 放行;被打回就改台账再交', + /* 被打回重做时要改的就是这几张 —— 不声明就写不进去 */ + writes: ['substitution.relation', 'substitution.difference_item', 'validation.record', 'demand.request', `${D}.verdict`], + reads: ['substitution.relation', 'substitution.difference_item', 'validation.record', 'demand.request', `${D}.verdict`], + view: 'landing-confirm', + tools: [], + /* 放行触达世界,必须人按一下 —— 引擎不自动收它 */ + guide: `落账确认那一屏摆着拟写 P-11 主记录与拟回写 P-01。**先看轨迹里有没有「验收被打回重做」**: +有 → 这一拍不是再提交一遍。照意见改**台账本身**(同 PK 覆盖写,不开新行): +· 他说推荐等级与明细不符 → 核对 \`substitution.relation.recommendation_level\` 与该关系明细的四态计数,不符的把 recommendation_reason 改实、把漏挂的验证要求补上; +· 他说 P-01 回写不全 → 补 \`demand.request\` 那五项; +· 他说证据不可信 → 改那几行 \`substitution.difference_item.evidence_ref\`(指到具体资料版本与页码); +· 没写具体意见 → 自己挑最站不住的一处改实,至少改对一处; +改完这一拍再 judge + submit。**基座那道闸:打回之后台账一个字没改就不许再提交。** + +没被打回(或已改过)→ 先裁三条裁量判据,然后 submit,同一拍连做: +· judge criterion="证据链可信:每条结论都能追溯到 P-08 / P-10 / P-06 的具体记录,或本单数据工单的创建记录(人工录入)" —— 逐条看 evidence_ref 指不指得到具体记录; +· judge criterion="硬约束项未被自动判 MATCH:封装 / 工艺 / 电气边界等硬约束的 MATCH 都有证据支持" —— 看 hard 且 match 的行 evidence_ref 是否非空且具体; +· judge criterion="推荐等级与差异明细一致:存在 UNKNOWN / CONDITIONAL 的候选没有给「推荐」" —— 逐候选核对; +**裁成不满足照样能提交** —— 理由连着卡一起交给签字的人。criterion 照判据名整句原样抄。 +这一单没有分支去向,只发一口 \`assessment-released\`,不必你选出口。终局唯放行:你不能自己宣布完成。`, + }, +]; + +/** + * 阶段 —— 进度条的刻度,只给人看。除放行外每个计划项恰属一个阶段; + * 放行那一格由基座统一加,人看到的是 **x/6** —— 与文档的步骤 0.5 / 1 / 2 / 3 / 4 / 5 六步逐格对齐: + * 0.5 启动与存在性检查(等待数据)· 1 建立评估上下文 · 2 读取并标准化 · 3 逐项差异评估 · 4 FAE 审核与补证(含拟落账)· 5 提交评审放行(基座那格) + */ +export const ASSESSMENT_PHASES = [ + { name: '启动与存在性检查', items: ['S0_bind', 'S0d_p08_master', 'S0d_p10_document'] }, + { name: '建立评估上下文', items: ['S1_input_confirm'] }, + { name: '读取并标准化资料', items: ['S2_normalize'] }, + { name: '逐项差异评估', items: ['S3_assess'] }, + { name: 'FAE 审核与补证', items: ['S4_review', 'S5_prepare_landing'] }, +]; diff --git a/activities/part-substitution-assessment/src/constants.ts b/activities/part-substitution-assessment/src/constants.ts new file mode 100644 index 0000000..1febf6a --- /dev/null +++ b/activities/part-substitution-assessment/src/constants.ts @@ -0,0 +1,8 @@ +/** 清单与案例模型共用的常量 —— 单独成文件,免得 manifest ↔ case-model 循环 import 撞 TDZ。 */ +export const ACTIVITY_ID_TEXT = 'part-substitution-assessment'; +/** 活动自持单据的域名 */ +export const D = 'sub_eval'; +/** GOV 差异规则版本 —— 随包冻结,随每条结论落账(rule_version) */ +export const RULE_VERSION = 'R-2026.07'; +export const TOOL_COMPARE = 'part-substitution-assessment.compare-parameters'; +export const TOOL_RECOMMEND = 'part-substitution-assessment.recommend'; diff --git a/activities/part-substitution-assessment/src/index.ts b/activities/part-substitution-assessment/src/index.ts new file mode 100644 index 0000000..71c42a2 --- /dev/null +++ b/activities/part-substitution-assessment/src/index.ts @@ -0,0 +1,11 @@ +/** + * ACT-WORK-05 · 差异评估 —— 活动包代码入口(ADR-004:默认导出 defineActivity 的返回值)。 + * + * 这个活动没有 `run`。案例活动的推进由 Loop 驱动,行为全部写在清单里: + * 案例模型 + 说明书 + 步骤剧本 + 三条技能 + 台账声明 + 五张 HTML 报告模版。 + * 这个文件之所以还存在,是因为清单的 `entry` 指着它 —— + * 它是**被静态审扫描的产物文本**(查 import 与全局引用,证明活动包零环境能力)。 + */ +import { defineActivity } from '@sdk'; + +export default defineActivity({ name: 'part-substitution-assessment' }); diff --git a/activities/part-substitution-assessment/src/manifest.ts b/activities/part-substitution-assessment/src/manifest.ts new file mode 100644 index 0000000..dd4d2a9 --- /dev/null +++ b/activities/part-substitution-assessment/src/manifest.ts @@ -0,0 +1,618 @@ +/** + * 活动包清单 —— ACT-WORK-05 差异评估(案例活动)。 + * + * 业务出处:`docs/SS02-ACT-WORK-05-html/`(活动流程与工单说明 / 一键启动入参说明 / + * 《SS02-SS03-SS04_Demo台账字段细化与统一方案》/ 四份目标件 / 全流程分支图)。 + * 骨架照 E04 / I01 已验证的样子:双级入参 → 活动自持单据 + 共享主数据 → decide 循环做中间审核 → + * 终局放行。三处与前两个活动刻意不同,写在这里免得下一个读者当成疏漏: + * ① **主数据是七张(P-08 主 + P-08 参数子表 / P-10 / P-01 / P-11 主+子 / P-06)**,物理表由平台基线 + * (`apps/api/src/app/seed-mvp-data.ts`)物化,这里只**追加**本活动要用的列与标记 + * (required / tally / refersTo / requiredWhen 是活动的授权面;声明合并是纯 add-column)。 + * **P-08 的标准化参数集是独立子表 `parts.parameter`**(2026-08-27 结构改:用户核对实跑 + * 页面后指出必须与目标件结构一致——目标件《数据工单-01》本就是两张表,塞进一个文本列 + * 违反《统一方案》§六「重复明细用子表承载,不在单一文本字段堆叠」)。 + * ② **数据工单**(PN 不在库时让人从零建整条主数据)= 零输入执行工单 + 工作区的件 + * (`mine:parts.profile` / `mine:parts.parameter` / `mine:parts.document` 可加行), + * 确认落草稿层、放行并入正式表(守铁律②;文档里「确认即入库」在本平台落成「无审核环节、 + * 放行并入」)。一张台账表一张单(P-08 主记录 + 参数子表算同一张数据工单 —— 目标件是 + * 同一份工单卡里的两张表)。 + * ③ 逐项四态与推荐等级**由两枚纯工具算**(规则同时以 D01/D02 两张 DMN 随包冻结当文档), + * 模型只负责对照表、证据与影响说明 —— 硬约束 MISMATCH 不可能被措辞改判。 + */ +import type { ActivityManifest, DmnModel } from '@contracts'; +import { activityIdSchema } from '@contracts'; +import { ASSESSMENT_SKILLS } from './skills.ts'; +import { CMMN_XML, NARRATIVE, ASSESSMENT_PHASES, ASSESSMENT_STEPS } from './case-model.ts'; +import { P08_MASTER_CREATE, P10_DOCUMENT_CREATE, EVAL_INPUT_LIST, DIFFERENCE_REVIEW, LANDING_CONFIRM } from './views/report.ts'; +import { ACTIVITY_ID_TEXT, D, TOOL_COMPARE, TOOL_RECOMMEND } from './constants.ts'; + +export { D, RULE_VERSION, TOOL_COMPARE, TOOL_RECOMMEND } from './constants.ts'; +const ACTIVITY_ID = activityIdSchema.parse(ACTIVITY_ID_TEXT); + +/** + * 两张判定表 —— **文档形态**(求值器在 `apps/api/src/app/tools/first-party.ts`,与这里同一份规则): + * D01 逐参数四态、D02 推荐等级。都是 FIRST:规则从上往下第一条命中即出结论,顺序就是优先级。 + */ +export const D01_DMN: DmnModel['tables'][number] = { + id: 'd01-difference-status', + label: '差异四态 D01(R-2026.07)', + hitPolicy: 'FIRST', + inputs: [ + { name: 'compare_result', expression: 'compare_result' }, + { name: 'constraint_type', expression: 'constraint_type' }, + { name: 'evidence_present', expression: 'evidence_present' }, + ], + outputs: [{ name: 'difference_status' }, { name: 'risk_level' }], + rules: [ + { id: 'd01-u', when: ['"unknown"', '-', '-'], then: ['unknown', 'medium'], annotation: '一侧未披露 → UNKNOWN,挂验证任务' }, + { id: 'd01-m0', when: ['"equal","covers"', '"hard"', 'false'], then: ['conditional', 'medium'], annotation: '硬约束缺证据不判 MATCH' }, + { id: 'd01-m', when: ['"equal","covers"', '-', '-'], then: ['match', 'low'], annotation: '一致或候选范围盖住原范围' }, + { id: 'd01-c', when: ['"configurable","partial"', '-', '-'], then: ['conditional', 'medium'], annotation: '可调配成 / 部分重叠 → 条件' }, + { id: 'd01-x', when: ['"narrower","differs"', '"hard"', '-'], then: ['mismatch', 'high'], annotation: '硬约束不一致' }, + { id: 'd01-s', when: ['"narrower","differs"', '"soft"', '-'], then: ['conditional', 'medium'], annotation: '软约束不一致 → 评估影响' }, + ], +}; + +export const D02_DMN: DmnModel['tables'][number] = { + id: 'd02-recommendation', + label: '推荐等级 D02(R-2026.07)', + hitPolicy: 'FIRST', + inputs: [ + { name: 'hard_mismatch_total', expression: 'hard_mismatch_total' }, + { name: 'unknown_total', expression: 'unknown_total' }, + { name: 'configurable_total', expression: 'configurable_total' }, + { name: 'conditional_total', expression: 'conditional_total' }, + ], + outputs: [{ name: 'recommendation_level' }], + rules: [ + { id: 'd02-n', when: ['> 0', '-', '-', '-'], then: ['not_recommended'], annotation: '硬约束失败直接不推荐' }, + { id: 'd02-u', when: ['0', '> 0', '-', '-'], then: ['conditional'], annotation: '有 UNKNOWN → 等验证闭环' }, + { id: 'd02-a', when: ['0', '0', '> 0', '-'], then: ['alternate'], annotation: '只靠改外围配得成 → 备选' }, + { id: 'd02-c', when: ['0', '0', '0', '> 0'], then: ['conditional'], annotation: '其余条件项 → 条件推荐' }, + { id: 'd02-r', when: ['0', '0', '0', '0'], then: ['recommended'], annotation: '全 MATCH → 推荐' }, + ], +}; + +export const ASSESSMENT_DMN: DmnModel = { + drd: [ + { decision: 'd01-difference-status', requires: [], inputs: ['compare_result', 'constraint_type', 'evidence_present'] }, + { decision: 'd02-recommendation', requires: [], inputs: ['hard_mismatch_total', 'unknown_total', 'configurable_total', 'conditional_total'] }, + ], + tables: [D01_DMN, D02_DMN], +}; + +/** 字段声明的短写(与 E04 同一套写法:显式 primaryKey / masked,其余按需) */ +type F = { name: string; type: 'text' | 'number' | 'integer' | 'boolean' | 'date' | 'timestamp' | 'json'; label: string; primaryKey?: boolean; required?: boolean; expect?: boolean; tally?: string[]; auto?: boolean; distinct?: boolean; refersTo?: string; requiredWhen?: { column: string; value: string } }; +const col = (f: F) => ({ primaryKey: false, masked: false, ...f }); + +export const manifest: ActivityManifest = { + identity: { + activityId: ACTIVITY_ID, + name: 'ACT-WORK-05 · 差异评估', + packageVersion: '1.3.6', + category: '需求分析与方案匹配', + sdkVersion: '0.1.0-m5', + checksum: 'dev-checksum-part-substitution-assessment', + }, + + /* ── 契约七件 ────────────────────────────────────────────────── */ + contract: { + activityId: ACTIVITY_ID, + version: '1.0.0', + input: { + /* + * 一键启动只收 4 项(文档《一键启动入参说明》极简原则):客户 / 客户需求 / 原 PN / 候选 PN 数组。 + * 应用场景、BOM 位、替代类型、规则版本、负责人期限**不是入参** —— 启动后在执行工单 01 里补。 + * datasheet 选填文件:传了 AI 在数据工单件上预填,没传人全填(文档 0c:同为合法路径)。 + * `customerName` 只在客户不在库(分支 0a)时用:S0 发数据录入卡建档,名字先摆上去让人核。 + */ + data: { + type: 'object', + required: ['customerCode', 'requestDescription', 'originalInternalPn', 'candidateInternalPns'], + properties: { + customerCode: { type: 'string', title: '客户编码(L-02 客户主台账)', examples: ['CU-0142'] }, + customerName: { type: 'string', title: '客户名称(仅客户不在库时填,启动后先建档)', examples: ['深圳恒星电源有限公司'] }, + requestDescription: { + type: 'string', + title: '客户需求(原始描述 —— 据此新建 P-01 需求主记录 · 版本 V1)', + examples: ['工业电源项目在用 LM2596S-5.0(TI,12V→5V),原厂 PCN 转 NRND,客户要求验证替代料'], + }, + originalInternalPn: { type: 'string', title: '原内部料号(P-08)', examples: ['LM2596S-5.0'] }, + candidateInternalPns: { + type: 'array', + title: '候选内部料号(数组,≥1;不在库的启动后经数据工单创建)', + items: { type: 'string' }, + examples: [['XL2596S-5.0', 'LM2596S-ADJ']], + }, + datasheets: { + type: 'array', + format: 'file', + title: '候选 datasheet(选填;传了 AI 在数据工单里预填,没传人全填)', + items: { + type: 'object', + properties: { + name: { type: 'string', title: '文件名' }, + contentType: { type: 'string', title: '类型' }, + size: { type: 'integer', title: '字节数' }, + ref: { type: 'string', title: '存档号' }, + text: { type: 'string', title: '读出来的文本' }, + note: { type: 'string', title: '读取说明' }, + }, + }, + }, + }, + }, + messageAllowed: true, + messageHint: 'FAE 可在此说明客户的应用边界、验证条件或本轮评估的特殊要求', + }, + output: { + /* 单一必发口:本活动终点是 ACT-GATE-03 评审放行;下游 ACT-WORK-08 尚未实现,按「契约先立」声明 */ + mandatory: [ + { + name: 'assessment-released', + description: '差异评估结论已落账(P-11 替代关系主记录 + 差异明细、P-01 回写)—— 供 ACT-WORK-08 证据归集消费;当前无消费者,载荷 = 已落地事实', + payload: { + type: 'object', + required: ['evalRef', 'requestId', 'relationTotal'], + properties: { + evalRef: { type: 'string', title: '评估案号' }, + requestId: { type: 'string', title: '需求编号(P-01)' }, + relationTotal: { type: 'integer', title: '落账的替代关系条数' }, + recommendedTotal: { type: 'integer', title: '推荐' }, + conditionalTotal: { type: 'integer', title: '条件推荐' }, + alternateTotal: { type: 'integer', title: '备选' }, + notRecommendedTotal: { type: 'integer', title: '不推荐' }, + }, + }, + }, + ], + selective: [], + }, + requiredDeliverables: [ + { key: 'eval-input', label: '评估输入清单', ledger: `${D}.input_gap`, ledgers: [`${D}.input_gap`, `${D}.pn_check`, `${D}.verdict`], editableAtRelease: [] }, + { key: 'difference-items', label: '差异评估结论(P-11 差异明细)', ledger: 'substitution.difference_item', ledgers: ['substitution.difference_item', 'substitution.relation'], editableAtRelease: [] }, + { key: 'landing', label: '拟落账内容(P-11 主记录 + P-01 回写)', ledger: 'substitution.relation', ledgers: ['substitution.relation', 'demand.request'], editableAtRelease: [] }, + ], + /* + * 验收判据 —— L1/L2 只读基座读数;L4 三条是文档验收工单 01/02 里留给人的裁量; + * 「推荐等级与明细一致」「硬约束不判 MATCH」机器已由工具守住,这里仍留 L4 让签字的人过目。 + */ + acceptanceCriteria: [ + { + key: 'input-confirmed', + label: '评估输入已经 PW 补齐确认:执行工单 01 已交回,缺口行的补充内容都有,补不了的留了 UNKNOWN', + level: 'L1', + predicate: `input_confirmed_total > 0 and ${D}_input_gap_rows > 0 and ${D}_input_gap_missing = 0`, + }, + { + key: 'review-approved', + label: '差异评估结论已经 FAE/RI 审核通过:验收工单 01 已过,不处在驳回待改状态', + level: 'L1', + predicate: 'review_approved_total > 0 and substitution_difference_item_rows > 0 and substitution_difference_item_missing = 0', + }, + { + key: 'every-candidate-assessed', + label: '每个未放弃的候选都有一条替代关系记录(N 候选 = N 条 P-11,并行独立落账)', + level: 'L2', + predicate: `substitution_relation_rows > 0 and substitution_relation_rows + ${D}_pn_check_exists_status_abandoned + 1 = ${D}_pn_check_rows`, + }, + { + key: 'every-item-has-status', + label: '关键参数差异均有明确状态:每条明细都是 MATCH / MISMATCH / UNKNOWN / CONDITIONAL 之一', + level: 'L2', + predicate: + 'substitution_difference_item_rows > 0 and substitution_difference_item_difference_status_match + substitution_difference_item_difference_status_mismatch + ' + + 'substitution_difference_item_difference_status_unknown + substitution_difference_item_difference_status_conditional = substitution_difference_item_rows', + }, + { + key: 'unknown-has-disposition', + label: 'UNKNOWN 项均有去向:每个 UNKNOWN 都挂了验证任务或补来源动作,影响说明与证据引用逐条齐全', + level: 'L2', + predicate: 'substitution_difference_item_missing = 0', + }, + { + key: 'judged-by-rule', + label: '四态与推荐等级由规则算出:逐参数比对工具与推荐定级工具都真调过', + level: 'L2', + predicate: `tool_part_substitution_assessment_compare_parameters_calls > 0 and tool_part_substitution_assessment_recommend_calls > 0`, + }, + { + key: 'analysis-status-confirmed', + label: '分析状态与客户批准状态分离:每条 P-11 只写分析层 analysis_status = FAE 确认,规则版本已锁定随结论落账', + level: 'L2', + predicate: 'substitution_relation_analysis_status_fae_confirmed = substitution_relation_rows and substitution_relation_missing = 0', + }, + { + key: 'p01-writeback-complete', + label: '回写 P-01 字段完整:风险等级、验证要求、输出链接、下一步动作、当前阶段五项齐全', + level: 'L2', + predicate: 'demand_request_rows > 0 and demand_request_missing = 0', + }, + { key: 'evidence-credible', label: '证据链可信:每条结论都能追溯到 P-08 / P-10 / P-06 的具体记录,或本单数据工单的创建记录(人工录入)', level: 'L4' }, + { key: 'hard-not-auto-match', label: '硬约束项未被自动判 MATCH:封装 / 工艺 / 电气边界等硬约束的 MATCH 都有证据支持', level: 'L4' }, + { key: 'recommendation-consistent', label: '推荐等级与差异明细一致:存在 UNKNOWN / CONDITIONAL 的候选没有给「推荐」', level: 'L4' }, + /* L5 是责任关:那张卡本身就是这道关,卡面上不摆它(基座统一滤) */ + { key: 'gate03-release', label: 'ACT-GATE-03 评审放行:签下去 P-11 落账、P-01 回写,结论供下游消费', level: 'L5' }, + ], + revisableAtRelease: [], + prohibitions: [ + { key: 'no-fabricated-parameter', statement: 'UNKNOWN 是一等公民:查不到的参数值必须显式写「未披露」并记去向,不得伪造、不得用估计值或空串冒充' }, + { key: 'no-override-hard-mismatch', statement: '硬约束 MISMATCH 不得被任何措辞改判 MATCH;要改只能补证据后重比' }, + { key: 'no-customer-approval-write', statement: '客户批准状态由独立审批流维护,本活动不写 customer_approval_status(没有这一列的写权)' }, + { key: 'no-commercial-judgement', statement: '本活动只答技术可替代性:不做数量、价格、交期、采购判断' }, + { key: 'no-rebind', statement: '启动绑定的 4 项(客户 / 需求 / 原 PN / 候选数组)工单内不可改;绑错只能退回触发方重新启动' }, + { key: 'no-external-write', statement: '放行前不得触达外部系统 —— 触达世界的动作集中在放行那一刻' }, + ], + authorization: { + discretion: [], + preauthorizedActions: [], + /* + * 基线:数据工单 ≤2 + 候选放弃/创建决策 ≤2 + 新客户录入卡 1 + 执行单 01 + 审核决策 1 + 放行 1 = 8; + * 审核循环预留两轮(+4)= 12。cap 必须严格大于最后一次拍板时的实际次数(E04 实测栽过),留到 16。 + */ + humanCallBudget: 16, + }, + resources: { + tools: [{ name: TOOL_COMPARE }, { name: TOOL_RECOMMEND }], + skills: ASSESSMENT_SKILLS.map((s) => s.id), + models: ['deepseek-v4-flash'], + roles: ['FAE/RI'], + budget: { steps: 90, tokens: 600_000, activeMinutes: 120, humanCalls: 16 }, + }, + }, + + /* ── 声明 ────────────────────────────────────────────────────── */ + declarations: { + models: ['deepseek-v4-flash'], + tools: [{ name: TOOL_COMPARE }, { name: TOOL_RECOMMEND }], + ledger: [ + /* L-02 客户主台账:只在分支 0a(客户不在库)由数据录入卡建一行 —— 录入卡写的列都得声明 */ + { + domain: 'customer', + object: 'profile', + kind: 'master', + label: '客户档案', + fields: [ + col({ name: 'customer_code', type: 'text', label: '客户编码', primaryKey: true }), + col({ name: 'name', type: 'text', label: '客户名称', required: true }), + col({ name: 'industry', type: 'text', label: '所属行业', expect: true }), + col({ name: 'region', type: 'text', label: '区域', expect: true }), + ], + }, + /* P-08 芯片主数据:数据工单建整条;标准化参数集已改子表 parts.parameter(2026-08-27, + 用户看了实跑页面指出「必须与目标件结构一致」——目标件本就是两张表,一张主记录一张 + 参数子表,塞进一个文本列违反《统一方案》§六「重复明细用子表承载」) */ + { + domain: 'parts', + object: 'profile', + kind: 'master', + label: '芯片主数据(P-08)', + fields: [ + col({ name: 'internal_pn', type: 'text', label: '内部料号', primaryKey: true }), + col({ name: 'brand_name', type: 'text', label: '品牌名称', required: true }), + col({ name: 'manufacturer_name', type: 'text', label: '制造商名称', expect: true }), + col({ name: 'specification_description', type: 'text', label: '规格描述', required: true }), + col({ name: 'package', type: 'text', label: '封装', required: true }), + col({ name: 'process_technology', type: 'text', label: '工艺', expect: true }), + col({ name: 'lifecycle_status', type: 'text', label: '生命周期状态', required: true, tally: ['active', 'nrnd', 'eol', 'discontinued', 'risk'] }), + col({ name: 'eol_pcn_status', type: 'text', label: 'EOL/PCN 状态', expect: true }), + col({ name: 'datasheet_ref', type: 'text', label: 'Datasheet 引用', expect: true }), + col({ name: 'datasheet_version', type: 'text', label: 'Datasheet 版本', expect: true }), + col({ name: 'application_scenarios', type: 'text', label: '适配应用场景', expect: true }), + ], + }, + /* P-08 子表:标准化参数集,一行一参数,internal_pn 是引用墙(查无那颗主记录当场拒) */ + { + domain: 'parts', + object: 'parameter', + kind: 'master', + label: '标准化参数集(P-08 子表)', + fields: [ + col({ name: 'internal_pn', type: 'text', label: '所属料号', primaryKey: true, refersTo: 'parts.profile.internal_pn' }), + /* + * `distinct` 是为了让「两颗料是不是用同一套参数名」变成**基座算得出的数** + * (`parts_parameter_distinct_param_name`)—— 见 CMMN 的 s_pns_resolved: + * 参数行数 = 不同参数名数 × 建过的料数,只有每颗料的名字集合一模一样时才成立。 + * 2026-08-27 实测:模型给第二颗料写英文 key(`input_voltage_range`), + * 而原 PN 在库里是中文「输入电压范围」—— 名字是主键的一半,对不上就没法逐项比。 + * 措辞写过两遍都没拦住(设计律第六条:措辞治不了的结构治)。 + */ + col({ + name: 'param_name', + type: 'text', + label: '参数名', + primaryKey: true, + distinct: true, + /* + * **参数名只能用台账里已经在用的那几个**(自指引用)—— 比对是逐参数对着比的, + * 候选身上有一个原 PN 没有的维度,本来也无从比起;名字对不上更是直接判成 UNKNOWN。 + * 2026-08-27 实测三次:模型给新料写英文 key(`input_voltage_range`), + * 而库里既有行是中文「输入电压范围」—— 剧本写过两遍、又加了一条乘法对账 + * (行数 = 不同名字数 × 建过的料数)仍拦不住**只建一颗**的那一路(5 = 5×1 恒成立)。 + * 自指是唯一在一颗料时也咬得住的:写下去那一刻基座去这一列里查,查无此值当场拒。 + * 代价(已知约束):真要引入一个全新的参数维度,得先有一颗料用过它 —— + * MVP 的品类词汇表是固定的七项,够用;将来要放开,改成引用一张参数字典表。 + */ + refersTo: 'parts.parameter.param_name', + }), + col({ name: 'param_value', type: 'text', label: '值', required: true }), + col({ name: 'param_unit', type: 'text', label: '单位', expect: true }), + col({ name: 'constraint_type', type: 'text', label: '约束类型', required: true, tally: ['hard', 'soft'] }), + col({ name: 'param_note', type: 'text', label: '说明', expect: true }), + ], + }, + /* P-10 原厂技术资料库:数据工单建;评估时只读做证据回链 */ + { + domain: 'parts', + object: 'document', + kind: 'master', + label: '原厂技术资料库(P-10)', + fields: [ + col({ name: 'internal_pn', type: 'text', label: '关联内部料号', primaryKey: true }), + col({ name: 'doc_seq', type: 'text', label: '资料序号(同一料号下 01/02…)', primaryKey: true }), + col({ name: 'document_type', type: 'text', label: '资料类型', required: true, tally: ['datasheet', 'app_note', 'reference_design', 'white_paper', 'sample_doc', 'commitment_letter', 'other'] }), + col({ name: 'brand_name', type: 'text', label: '品牌名称', expect: true }), + col({ name: 'document_title', type: 'text', label: '资料标题', required: true }), + col({ name: 'document_version', type: 'text', label: '资料版本', required: true }), + col({ name: 'document_ref', type: 'text', label: '资料文件链接', required: true }), + col({ name: 'citation_locator', type: 'text', label: '证据定位(页码/章节/表格)', expect: true }), + col({ name: 'document_status', type: 'text', label: '资料状态', required: true, tally: ['valid', 'expired', 'pending', 'void'] }), + ], + }, + /* P-01 需求主记录:S0 新建 V1,放行时回写五项(current_stage = gate03 那一刻五项必填) */ + { + domain: 'demand', + object: 'request', + kind: 'master', + label: '客户需求主记录(P-01)', + fields: [ + col({ name: 'request_id', type: 'text', label: '需求编号', primaryKey: true }), + col({ name: 'customer_code', type: 'text', label: '客户编码', required: true, refersTo: 'customer.profile.customer_code' }), + col({ name: 'requirement_version', type: 'text', label: '需求版本', required: true }), + col({ name: 'request_type', type: 'text', label: '需求类型', required: true }), + col({ name: 'request_description', type: 'text', label: '需求描述', required: true }), + col({ name: 'input_snapshot_ref', type: 'text', label: '输入快照', required: true }), + col({ name: 'original_internal_pn', type: 'text', label: '原内部料号', required: true }), + col({ name: 'bom_position', type: 'text', label: 'BOM 位', expect: true }), + col({ name: 'application_scenario', type: 'text', label: '应用场景', expect: true }), + col({ name: 'technical_constraints', type: 'text', label: '技术约束' }), + col({ name: 'risk_level', type: 'text', label: '风险等级', tally: ['low', 'medium', 'high', 'critical'], requiredWhen: { column: 'current_stage', value: 'gate03' } }), + col({ name: 'verification_requirement', type: 'text', label: '验证/复测/确认要求', requiredWhen: { column: 'current_stage', value: 'gate03' } }), + col({ name: 'request_status', type: 'text', label: '需求状态', required: true, tally: ['pending', 'responded', 'won', 'abandoned', 'closed'] }), + col({ name: 'current_activity', type: 'text', label: '当前 Activity', requiredWhen: { column: 'current_stage', value: 'gate03' } }), + col({ name: 'current_stage', type: 'text', label: '当前阶段' }), + col({ name: 'next_action', type: 'text', label: '下一步动作', requiredWhen: { column: 'current_stage', value: 'gate03' } }), + col({ name: 'output_ref', type: 'text', label: '标准输出链接', requiredWhen: { column: 'current_stage', value: 'gate03' } }), + ], + }, + /* P-11 替代关系主记录:一候选一条;两枚 PN 都是引用墙(查无此料当场拒 —— 存在性检查的硬门) */ + { + domain: 'substitution', + object: 'relation', + kind: 'master', + label: '替代关系主记录(P-11)', + fields: [ + col({ name: 'substitution_relation_id', type: 'text', label: '替代关系ID', primaryKey: true }), + col({ name: 'eval_ref', type: 'text', label: '评估案号', required: true }), + col({ name: 'request_id', type: 'text', label: '关联需求编号', required: true }), + col({ name: 'bom_position', type: 'text', label: '关联 BOM 位', expect: true }), + col({ name: 'original_internal_pn', type: 'text', label: '原内部料号', required: true, refersTo: 'parts.profile.internal_pn' }), + col({ name: 'candidate_internal_pn', type: 'text', label: '候选内部料号', required: true, refersTo: 'parts.profile.internal_pn' }), + col({ name: 'substitution_type', type: 'text', label: '替代类型', required: true, tally: ['pin_to_pin', 'functional', 'parametric', 'other'] }), + col({ name: 'recommendation_level', type: 'text', label: '推荐等级', required: true, tally: ['recommended', 'conditional', 'alternate', 'not_recommended'] }), + col({ name: 'recommendation_reason', type: 'text', label: '推荐理由', required: true }), + col({ name: 'difference_summary', type: 'text', label: '差异摘要', required: true }), + col({ name: 'risk_level', type: 'text', label: '替代风险等级', required: true, tally: ['low', 'medium', 'high', 'critical'] }), + col({ name: 'verification_requirement', type: 'text', label: '验证要求', requiredWhen: { column: 'recommendation_level', value: 'conditional' } }), + col({ name: 'validation_id', type: 'text', label: '关联验证ID' }), + col({ name: 'analysis_status', type: 'text', label: '分析状态', required: true, tally: ['ai_draft', 'fae_confirmed', 'pending_customer', 'customer_approved', 'rejected', 'void'] }), + col({ name: 'analysis_report_ref', type: 'text', label: '替代分析报告', expect: true }), + col({ name: 'confidence_score', type: 'number', label: '证据可信度', expect: true }), + col({ name: 'rule_version', type: 'text', label: '差异规则版本', required: true }), + ], + }, + /* P-11 差异明细子表:一条参数一条记录;relation id 上 distinct 让基座数「几条关系有明细」 */ + { + domain: 'substitution', + object: 'difference_item', + kind: 'master', + label: '差异明细(P-11 子表)', + fields: [ + col({ name: 'substitution_relation_id', type: 'text', label: '替代关系ID', primaryKey: true, distinct: true, refersTo: 'substitution.relation.substitution_relation_id' }), + col({ name: 'difference_item_id', type: 'text', label: '差异明细ID', primaryKey: true }), + col({ name: 'parameter_name', type: 'text', label: '标准参数名', required: true }), + col({ name: 'original_value', type: 'text', label: '原物料参数值', required: true }), + col({ name: 'candidate_value', type: 'text', label: '候选物料参数值', required: true }), + col({ name: 'parameter_unit', type: 'text', label: '参数单位', expect: true }), + col({ name: 'constraint_type', type: 'text', label: '约束类型', required: true, tally: ['hard', 'soft'] }), + col({ name: 'compare_result', type: 'text', label: '比对结果(工具出参)', expect: true }), + col({ name: 'difference_status', type: 'text', label: '差异状态', required: true, tally: ['match', 'mismatch', 'unknown', 'conditional'] }), + col({ name: 'impact_statement', type: 'text', label: '影响说明(MATCH 写「无」)', required: true }), + col({ name: 'unknown_disposition', type: 'text', label: 'UNKNOWN 去向(验证任务号 / 补来源动作)', requiredWhen: { column: 'difference_status', value: 'unknown' } }), + col({ name: 'risk_level', type: 'text', label: '风险等级', required: true, tally: ['low', 'medium', 'high'] }), + col({ name: 'evidence_ref', type: 'text', label: '差异证据引用', required: true }), + col({ name: 'confidence', type: 'number', label: 'AI 置信度', expect: true }), + col({ name: 'rule_version', type: 'text', label: '差异规则版本', required: true }), + ], + }, + /* P-06 验证记录:事实类 —— 本活动只写「验证要求」(状态 not_started),不经数据工单建 */ + { + domain: 'validation', + object: 'record', + kind: 'master', + label: '芯片验证记录(P-06)', + fields: [ + col({ name: 'validation_id', type: 'text', label: '验证ID', primaryKey: true }), + col({ name: 'request_id', type: 'text', label: '关联需求编号', required: true }), + col({ name: 'validation_internal_pn', type: 'text', label: '验证内部料号', required: true, refersTo: 'parts.profile.internal_pn' }), + col({ name: 'validation_type', type: 'text', label: '验证类型', required: true, tally: ['pin_to_pin', 'functional', 'reliability', 'certification', 'retest'] }), + col({ name: 'validation_status', type: 'text', label: '验证状态', required: true, tally: ['not_started', 'in_progress', 'passed', 'failed', 'conditional', 'pending_evidence'] }), + col({ name: 'test_condition', type: 'text', label: '测试条件', expect: true }), + col({ name: 'next_validation_action', type: 'text', label: '后续验证动作', required: true }), + col({ name: 'evidence_ref', type: 'text', label: '验证证据引用', expect: true }), + ], + }, + /* ── 活动自持单据(record,caseKey eval_ref)── */ + { + domain: D, + object: 'pn_check', + kind: 'record', + caseKey: 'eval_ref', + label: '料号存在性核对', + fields: [ + col({ name: 'eval_ref', type: 'text', label: '评估案号', primaryKey: true }), + col({ name: 'internal_pn', type: 'text', label: '内部料号', primaryKey: true }), + col({ name: 'role', type: 'text', label: '角色', required: true, tally: ['original', 'candidate'] }), + col({ name: 'exists_status', type: 'text', label: '在库状态', required: true, tally: ['found', 'absent', 'created', 'abandoned'] }), + /* + * 「在库」不是模型说了算的一句话 —— 判 found 就必须把**在主数据里真找到的那个料号**填在这里, + * 基座拿它去 `parts.profile` 查(refersTo),查无此值当场拒。requiredWhen 让这一格只对 found 行必填, + * 而 S0_bind 的 doneWhen 里有 `_missing = 0` —— 于是「判了 found 却填不出依据」这一步就收不掉。 + * 2026-08-27 实测逼出来的:原 PN 根本不在库,模型把两颗都写成 found、交代里还说「都在库」, + * 硬阻塞那条路整个被跳过(剧本早写着「整表在你的作用域里逐个核对」—— 措辞治不了的结构治)。 + */ + col({ + name: 'found_pn_ref', + type: 'text', + label: '在库核对依据', + refersTo: 'parts.profile.internal_pn', + requiredWhen: { column: 'exists_status', value: 'found' }, + }), + col({ name: 'abandon_reason', type: 'text', label: '放弃原因', requiredWhen: { column: 'exists_status', value: 'abandoned' } }), + col({ name: 'note', type: 'text', label: '备注' }), + ], + }, + { + domain: D, + object: 'input_gap', + kind: 'record', + caseKey: 'eval_ref', + label: '评估输入清单', + fields: [ + col({ name: 'eval_ref', type: 'text', label: '评估案号', primaryKey: true }), + col({ name: 'item_key', type: 'text', label: '输入项键', primaryKey: true }), + col({ name: 'input_item', type: 'text', label: '输入项', required: true }), + col({ name: 'source_ledger', type: 'text', label: '来源台账', expect: true }), + col({ name: 'status', type: 'text', label: '状态', required: true, tally: ['gap', 'default', 'ok'] }), + col({ name: 'detail', type: 'text', label: '绑定值 / 缺口说明', expect: true }), + col({ name: 'supplement', type: 'text', label: '补充内容', requiredWhen: { column: 'status', value: 'gap' } }), + col({ name: 'origin', type: 'text', label: '来源(ai/human-added)' }), + ], + }, + { + domain: D, + object: 'verdict', + kind: 'record', + caseKey: 'eval_ref', + label: '本次评估结论', + fields: [ + col({ name: 'eval_ref', type: 'text', label: '评估案号', primaryKey: true }), + col({ name: 'request_id', type: 'text', label: '需求编号' }), + col({ name: 'rule_version', type: 'text', label: '规则版本' }), + col({ name: 'original_internal_pn', type: 'text', label: '原内部料号' }), + col({ name: 'candidate_total', type: 'integer', label: '候选数' }), + col({ name: 'input_confirmed_total', type: 'integer', label: '评估输入已确认' }), + col({ name: 'review_approved_total', type: 'integer', label: '差异结论已审核通过' }), + col({ name: 'landing_prepared_total', type: 'integer', label: '拟落账已备好' }), + col({ name: 'relation_total', type: 'integer', label: '替代关系条数' }), + col({ name: 'recommended_total', type: 'integer', label: '推荐' }), + col({ name: 'conditional_total', type: 'integer', label: '条件推荐' }), + col({ name: 'alternate_total', type: 'integer', label: '备选' }), + col({ name: 'not_recommended_total', type: 'integer', label: '不推荐' }), + col({ name: 'summary', type: 'text', label: '本次评估结论' }), + ], + }, + ], + listeners: [], + harness: { + memoryWindow: 24, + stallAfter: 'PT4H', + nudge: [{ after: 'PT2H', action: 'nudge' }], + retry: { times: 2, backoff: 'PT30S' }, + }, + }, + + /* ── 资产初始版 ──────────────────────────────────────────────── */ + assets: { + businessModel: { cmmnXml: CMMN_XML, narrative: NARRATIVE, dmn: ASSESSMENT_DMN, steps: ASSESSMENT_STEPS, phases: ASSESSMENT_PHASES }, + skills: ASSESSMENT_SKILLS, + /* + * 五个局面各一张: + * · `p08-master-create` —— S0d 摆,数据工单(P-08),件上可加行、可编辑; + * · `p10-document-create` —— S0d 摆,数据工单(P-10),同上; + * · `eval-input-list` —— S1 摆,评估输入清单:绑定区只读 + 缺口表可编辑; + * · `difference-review` —— S2/S3/S4 摆,差异明细 + 各候选推荐等级,只读; + * · `landing-confirm` —— S5/T_release 摆,拟写 P-11 / 拟回写 P-01,只读;放行后即归档件。 + */ + viewTemplates: [ + { name: 'p08-master-create', html: P08_MASTER_CREATE }, + { name: 'p10-document-create', html: P10_DOCUMENT_CREATE }, + { name: 'eval-input-list', html: EVAL_INPUT_LIST }, + { name: 'difference-review', html: DIFFERENCE_REVIEW }, + { name: 'landing-confirm', html: LANDING_CONFIRM }, + ], + cardSchemas: {}, + distillHooks: [{ on: 'terminal', prompt: '归纳本次差异评估:哪些候选、各自推荐等级与关键依据、UNKNOWN 挂了什么验证任务、审核是否被驳回过(为什么)、数据工单建了哪些主数据。' }], + }, + + /* + * ── 样例集:五条形状真不同(常备案例即验收案例)── + * 第一条满载且走「候选缺库 → 数据工单」那条最长的路(测试台落地即预填的是它);样例名 ≤14 字。 + * 库里只播了 LM2596S-5.0 / LM2596S-ADJ 两颗(见 seed-mvp-data.ts),XL2596S-5.0 / CN-DCDC-32V / LM2596S-3.3 刻意不在库。 + */ + samples: [ + { + name: '候选缺库·派数据工单', + input: { + customerCode: 'CU-0142', + requestDescription: '工业电源项目在用 LM2596S-5.0(TI,12V→5V),原厂 PCN 转 NRND,客户要求验证替代料;应用 12V→5V、工业温域、输入上限 40V', + originalInternalPn: 'LM2596S-5.0', + candidateInternalPns: ['XL2596S-5.0', 'LM2596S-ADJ'], + }, + expect: { ports: ['assessment-released'] }, + }, + { + name: '都在库·常路', + input: { + customerCode: 'CU-0142', + requestDescription: 'LM2596S-5.0 转 NRND,客户先评估同族可调版 LM2596S-ADJ 能否替代(愿意改外围);应用 12V→5V、工业温域', + originalInternalPn: 'LM2596S-5.0', + candidateInternalPns: ['LM2596S-ADJ'], + }, + expect: { ports: ['assessment-released'] }, + }, + { + name: '原PN缺库·硬阻塞', + input: { + customerCode: 'CU-0142', + requestDescription: '客户另一块板在用 LM2596S-3.3(3.3V 固定版),同批 PCN,要求评估 LM2596S-ADJ 替代;应用 12V→3.3V', + originalInternalPn: 'LM2596S-3.3', + candidateInternalPns: ['LM2596S-ADJ'], + }, + expect: { ports: ['assessment-released'] }, + }, + { + name: '三候选·含硬约束不推荐', + input: { + customerCode: 'CU-0142', + requestDescription: '工业电源 12V→5V,输入上限 40V,工业温域;三个候选:XL2596S-5.0、LM2596S-ADJ、国产 CN-DCDC-32V(输入上限只有 32V)', + originalInternalPn: 'LM2596S-5.0', + candidateInternalPns: ['XL2596S-5.0', 'LM2596S-ADJ', 'CN-DCDC-32V'], + }, + expect: { ports: ['assessment-released'] }, + }, + { + name: '新客户·先建档', + input: { + customerCode: 'CU-9001', + customerName: '深圳恒星电源有限公司', + requestDescription: '新客户口述:工业电源 12V→5V 在用 LM2596S-5.0,想评估 LM2596S-ADJ', + originalInternalPn: 'LM2596S-5.0', + candidateInternalPns: ['LM2596S-ADJ'], + }, + expect: { ports: ['assessment-released'] }, + }, + ], + + entry: { file: 'index.js', checksum: 'dev-entry-part-substitution-assessment' }, +}; diff --git a/activities/part-substitution-assessment/src/skills.ts b/activities/part-substitution-assessment/src/skills.ts new file mode 100644 index 0000000..03f6989 --- /dev/null +++ b/activities/part-substitution-assessment/src/skills.ts @@ -0,0 +1,55 @@ +/** + * ACT-WORK-05 差异评估的技能 —— 载方法,不载权力。 + * 剧本写「这一步做什么、写哪几列」,技能写「为什么这么判、拿不准时按哪条走」。 + */ +import { skillIdSchema } from '@contracts'; +import type { Skill } from '@contracts'; + +export const ASSESSMENT_SKILLS: Skill[] = [ + { + id: skillIdSchema.parse('substitution.normalize-parameters'), + label: '把多来源资料整成可比对的标准参数对照表', + applicability: '输入确认之后、逐项比对之前:原 PN 与每个候选的参数集要摆成同名同单位的一对一。', + method: [ + '参数集是独立子表 `parts.parameter`(P-08 的结构子表),一行一参数,按 `internal_pn` 归属主记录:列是 param_name / param_value / param_unit / constraint_type / param_note。', + '对照表按**原 PN 名下的那几行参数名**为骨架:原 PN 有的参数,候选名下没有同名那一行 → 候选值写「未披露」(它会成为 UNKNOWN);', + '候选多出来的参数不比(比对只回答「能不能替」,多出来的能力不构成差异)。', + '单位以原 PN 那一行的 param_unit 为准:候选单位不同先换算(mV→V、kHz→MHz),换算不了就不改值、在说明里写明 —— 不许静默改数。', + '约束类型以原 PN 那一行的 constraint_type 为准;原 PN 没标的按 GOV 口径:封装 / 工艺 / 电气边界(电压 / 电流 / 温度 / 阈值)一律 hard,其余 soft。', + '**缺参数不得伪造**:查不到的写「未披露」,不写估计值、不写「约」。', + ].join('\n'), + crystallized: [], + knowledgeRefs: ['标准化参数子表结构', '硬/软约束口径'], + version: '1.0.0', + }, + { + id: skillIdSchema.parse('substitution.difference-judgement'), + label: '逐项四态由工具算,证据与影响由你写', + applicability: '对照表齐了,要出 MATCH / MISMATCH / UNKNOWN / CONDITIONAL 时。', + method: [ + '四态**不许自己判**:调 `part-substitution-assessment.compare-parameters`,把每个候选的全部参数对一次性传进去(candidates 数组,一次一批)。', + '每对参数都带 `evidenceRef`(值从哪份记录来:「P-08」「P-10 Rev H §6.5」「数据工单 <单号> · 确认人 <人>」)——硬约束没有证据引用,工具不判 MATCH。', + '客户在应用场景里给了边界(如「输入上限 40V」)就写进那一对的 `requirement`(`>= 40`),候选不满足直接 MISMATCH。', + '工具出参照抄进 `substitution.difference_item`:difference_status / compare_result / risk_level 一字不改;', + '`impact_statement` 你写:MATCH 写「无」,其余说清对应用 / 验证 / 报价的影响;UNKNOWN 必须写 `unknown_disposition`(挂验证任务号或补来源动作),不许悬空。', + '推荐等级同样由工具定(`part-substitution-assessment.recommend`,传每个候选的 counts),`recommendation_reason` 照工具的 reason 扩写,不许把不推荐改成推荐。', + ].join('\n'), + crystallized: [], + knowledgeRefs: ['四态口径', '推荐等级四档'], + version: '1.0.0', + }, + { + id: skillIdSchema.parse('substitution.landing'), + label: '落账只写分析层,客户批准不碰', + applicability: '审核通过之后拟 P-11 / 回写 P-01 时。', + method: [ + '`analysis_status` 从 `ai_draft` 推到 `fae_confirmed`;`customer_approval_status` 由独立审批流维护 —— 本活动**没有这一列的写权**,写了会被拒。', + 'P-01 回写五项:risk_level(取各候选里最高的)、verification_requirement(把所有验证任务号列全)、output_ref(替代分析报告号)、next_action(「提交 ACT-GATE-03 评审放行」)、current_stage 写 `gate03`。', + '规则版本随结论落账:每条 P-11 主记录与差异明细都写 rule_version(工具出参的 ruleVersion),中途规则更新不影响进行中的评估。', + '被打回重做时改的是**台账本身**(理由 / 依据 / 去向),不是把同一份原样再递一遍。', + ].join('\n'), + crystallized: [], + knowledgeRefs: ['analysis_status 与 customer_approval_status 分离'], + version: '1.0.0', + }, +]; diff --git a/activities/part-substitution-assessment/src/views/report.ts b/activities/part-substitution-assessment/src/views/report.ts new file mode 100644 index 0000000..d3b355e --- /dev/null +++ b/activities/part-substitution-assessment/src/views/report.ts @@ -0,0 +1,657 @@ +/** + * ACT-WORK-05 差异评估的 HTML 报告模版 —— **活动自己持有的资产**,随包版本冻结。 + * + * 五个局面各一张,版面语言**逐块搬自** `docs/SS02-ACT-WORK-05-html/` 的四份目标件 + * (《HTML报告生成规范》§7:有目标件时「搬」,不要「照着做」——样式表整段搬,标记逐块搬, + * 只把写死的数据换成绑定): + * · `p08-master-create` —— S0d 摆,数据工单(P-08 芯片主数据),搬自「数据工单-01」 + * (2026-08-27:补齐目标件里原本就有、之前漏搬的【创建什么 · 表 2】标准化参数子表 `parts.parameter` + * —— 用户核对实跑页面后指出「页面结构必须与目标件一致」,目标件本就是两张表); + * · `p10-document-create` —— S0d 摆,数据工单(P-10 原厂技术资料),**没有自己的目标件** + * (规格里数据工单是「一个统一模板按目标台账实例化」),复用「数据工单-01」的样式表与版面骨架; + * · `eval-input-list` —— S0/S1 摆,评估输入清单,搬自「执行工单-01」; + * · `difference-review` —— S2/S3/S4 摆,差异评估结论审核,搬自「验收工单-01」; + * · `landing-confirm` —— S5/T_release 摆,评审放行与落账确认,搬自「验收工单-02」。 + * + * 目标件的样式表逐字节存在 `./target-style.ts`(`P08_CSS`/`EXEC_CSS`/`ACC1_CSS`/`ACC2_CSS`, + * 抽取与 diff 验证过程见 task-5-report.md)。**这份文件只做取值绑定,不算不判**; + * `BIND_COMMON`/`BIND_P08`/`BIND_EXEC`/`BIND_ACC1`/`BIND_ACC2` 是平台绑定层必须新增的东西 + * (目标件是写死数据的静态demo,没有「N 行草稿」「编辑态与归档态二选一」这些平台概念): + * 缺项红带、编辑闸/增删行按 `html.editable` 收起、序号列换成 CSS 计数器(目标件靠 JS 脚本 + * 重排数字,沙箱零脚本改用它)、`data-class-of` 的 `v-*` 别名(枚举列不许摆 ASCII 原值 —— + * 有色徽标的地方原样复制目标件自己那几条颜色声明当 `v-` 版,目标件本来是纯文字的地方 + * 就只补 `::after` 文案、不额外配色)。 + */ +import { P08_CSS, EXEC_CSS, ACC1_CSS, ACC2_CSS } from './target-style.ts'; +import { D } from '../constants.ts'; + +/* ==================================================================================== + * 绑定层公共开关 —— 五张模版共用,与目标件自己的样式表分开存(那份要保持逐字节可比) + * ==================================================================================== */ +const BIND_COMMON = ` +/* 只在「待处理」这一态露面;归档 / 验收只读态即便 HTML 里还带着 data-edit 也不摆闸和加行钮 + (目标件是静态 demo,不区分这两态;html.editable 是平台在 iframe 根节点上真开的关) */ +html:not(.editable) .jc-editgate, html:not(.editable) .jc-addrow { display: none !important; } +/* 「加一行」钮跟着紧邻的表进不进编辑态现身(目标件靠 JS 脚本的 classList.toggle('show',on), + 沙箱零脚本,改用 :has() 认「紧挨着的表是不是 .on」) */ +.jc-tbl-wrap:has(table.on) + .jc-addrow { display: flex; align-items: center; gap: 8px; } +/* 序号列交给 CSS 计数器 —— 目标件的 JS 脚本在增删行后重写 .jc-rn-num / .num 的文本, + 沙箱零脚本,新增的行 / 删掉的行让计数器自己算对,不必比对哪一行手改过数字。 + 两种列名都要接(.rn 用于 P08/P10/执行工单 —— 目标件里那三份自己就用它; + .num 用于两份验收工单 —— 目标件里那两份自己就用它,静态数字,这里换成动态计数)。 */ +.tbl-wrap table { counter-reset: rn; } +.tbl-wrap table td.rn { counter-increment: rn; } +.tbl-wrap table td.rn .jc-rn-num::before { content: counter(rn); } +.tbl-wrap table td.num { counter-increment: rn; } +.tbl-wrap table td.num::before { content: counter(rn); } +/* 缺项红带 —— 目标件没有这个概念(它是静态 demo,不会「缺东西」); + 这是本仓的必填提示机制,与提交闸同源,配色用目标件自己 :root 里那两个 --danger 变量 + (四份目标件的 :root 对这两个变量给的是同一组值,借用不算改目标件的数值)。 */ +.jc-gapbar { display: none; } +html.editable .jc-gapbar { + display: flex; align-items: flex-start; gap: 8px; margin: 0 0 10px; padding: 9px 12px; + border-radius: 9px; background: #fff5f5; border: 1px solid #f3b9b5; color: var(--danger); font-size: 12px; line-height: 1.65; +} +.jc-gapbar b { font-weight: 800; } +.jc-gapbar span { color: #9a3b36; } +html.editable .jc-gapbar.v-0 { display: none; } +`; + +/* + * ==================== 徽标别名的生成器 ==================== + * + * **2026-08-27 实测事故**:手写的 `.jc-tag.v-pin_to_pin::after{…}` 永远匹配不上,件上显示「待定」, + * 而台账里 `substitution_type` 明明是 `pin_to_pin`。病根是平台有两套互相打架的消毒规则: + * `data-class-of` 投影出的 class 走 `view-render.ts` 的 `classToken`(只留 `[a-z0-9-]`, + * **吃掉下划线**,`pin_to_pin` → `v-pintopin`,封顶 24 字);基座读数名走 `engines.ts` 的 + * `slug`(只留 `[a-z0-9_]`,吃掉连字符)。两套规则不一样,tally 值一旦带下划线,手写的 + * `.v-xxx` 选择器就必然是错的。**判据那一侧(读数名)一个字都不碰**——那已经审查通过、 + * 与 `slug` 一致;这里改的只是展示层:选择器一律用 `vtok()` 从 tally 值**算**出来,不再手写。 + */ +/** 必须与 `classToken` 一字不差:小写、只留 `[a-z0-9-]`、封顶 24 字。 */ +const vtok = (v: string): string => v.toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 24); +/** 一族徽标的 CSS:选择器与文案从 `[值, 人读名, 可选颜色声明]` 表算出来,值与文案成对写在一处 */ +type BadgeSpec = readonly [value: string, label: string, color?: string]; +const badgeCss = (selector: string, specs: readonly BadgeSpec[]): string => + specs + .map(([v, label, color]) => { + const cls = `${selector}.v-${vtok(v)}`; + return color === undefined ? `${cls}::after { content: "${label}"; }` : `${cls}::after { content: "${label}"; }\n${cls} { ${color} }`; + }) + .join('\n'); + +const OK = 'color: var(--ok); background: var(--ok-soft); border-color: #c9ecc2;'; +const DANGER = 'color: var(--danger); background: var(--danger-soft); border-color: #f3b9b5;'; +const AMBER = 'color: #8f6a12; background: #fdf3d7; border-color: #ecd9a0;'; +const MUTED = 'color: var(--ink-3); background: #eef1f6; border-color: var(--line);'; + +/* ==================== 数据工单(P08/P10 共用):徽标别名 ==================== */ +const BIND_P08 = ` +/* 生命周期 / 资料类型 / 资料状态 三个枚举列共用同一个徽标类 —— 取值域互不重叠(active/nrnd/eol/ + discontinued/risk 与 datasheet/app_note/… 与 valid/expired/pending/void 三组没有一个词撞车), + 同一页内不必再分家。配色借的是本设计语言在别的目标件里已经出现过的那几个色(ok/danger/琥珀), + 不是新配的颜色。 */ +.stx { display: inline-block; font-size: 11px; font-weight: 700; padding: 1px 8px; border-radius: 999px; border: 1px solid transparent; white-space: nowrap; } +${badgeCss('.stx', [ + ['active', 'Active', OK], + ['nrnd', 'NRND', AMBER], + ['eol', 'EOL', DANGER], + ['discontinued', '停产', MUTED], + ['risk', '风险', DANGER], + ['datasheet', 'Datasheet', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['app_note', '应用笔记', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['reference_design', '参考设计', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['white_paper', '白皮书', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['sample_doc', '样片资料', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['commitment_letter', '承诺函', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['other', '其他', 'color: var(--ink-2); background: var(--soft); border-color: var(--line);'], + ['valid', '有效', OK], + ['expired', '过期', DANGER], + ['pending', '待核实', AMBER], + ['void', '作废', MUTED], +])} +/* + * 表 2(标准化参数集)的约束类型(硬/软)—— 目标件里这一格是字面类名 .ct.hard / .ct.soft + * (P08_CSS 已带这两条颜色声明,.ct 基座形状也在);平台的 data-class-of 走的是 + * v- 别名机制,不是字面枚举值,这里用 badgeCss 生成 .ct.v-hard / .ct.v-soft, + * 颜色原样照抄目标件那两条声明的数值(DANGER/MUTED 与 .ct.hard / .ct.soft 同一份值)。 + */ +${badgeCss('.ct', [ + ['hard', '硬约束', DANGER], + ['soft', '软约束', MUTED], +])} +`; + +/* ==================== 执行工单(评估输入清单):徽标别名 ==================== */ +const BIND_EXEC = ` +/* 存在性核对的两列(角色 / 在库状态)与评估输入清单的状态列共用目标件自己的 .st 徽标基座 —— + 取值域互不重叠(found/absent/created/abandoned 与 gap/default/ok 没有一个词撞车)。 + 四档配色**原样照抄目标件自己的 .st.bound / .st.ok / .st.miss / .st.def 那四条声明**,只换成 v- 版。 */ +${badgeCss('.st', [ + ['found', '在库', OK], + ['absent', '不在库', 'color: var(--human); background: var(--human-soft); border-color: var(--human-line);'], + ['created', '本单新建', 'color: var(--brand-deep); background: var(--brand-wash); border-color: var(--brand-soft);'], + ['abandoned', '已放弃', MUTED], + ['gap', '待补＊', 'color: var(--human); background: var(--human-soft); border-color: var(--human-line);'], + ['default', '默认·可改', 'color: var(--brand-deep); background: var(--brand-wash); border-color: var(--brand-soft);'], + ['ok', '齐备', OK], +])} +/* 角色(原 PN / 候选 PN)是分类标签不是状态,目标件里这类描述文字从不配色,这里只补 ::after 文案 */ +${badgeCss('.rl', [ + ['original', '原内部料号'], + ['candidate', '候选内部料号'], +])} +/* + * **补充内容按行投影必填**(2026-08-27 实测:11 行全摆红「必填」胶囊,而闸只认 3 行)—— + * \`sub_eval.input_gap.supplement\` 的必填是 \`requiredWhen:{status:'gap'}\`,按行不按列; + * 静态 \`class="req"\` 会把每一行都标必填。改成 \`\` 按本行的 + * status 值投影,只在 v-gap 那一档出红胶囊与行首红条,default / ok 两档不出。 + */ +td.sup.v-gap > .jc-vcell:empty::after { + content: "必填"; display: inline-flex; align-items: center; font-style: normal; font-size: 10px; font-weight: 700; + line-height: 1; padding: 3px 7px; border-radius: 5px; border: 1px dashed #f3b9b5; color: var(--danger); background: var(--danger-soft); +} +tbody tr:has(td.sup.v-gap > .jc-vcell:empty) td { background: #fffbfb; } +tbody tr:has(td.sup.v-gap > .jc-vcell:empty) td.rn { color: var(--danger); font-weight: 800; } +`; + +/* ==================== 验收工单 01(差异评估结论审核):徽标别名 ==================== */ +const BIND_ACC1 = ` +/* 差异四态与推荐等级**都**落在这一屏(本活动数据面的既有约定 —— 各候选推荐等级摘要与 + 逐项差异明细同屏摆),两者取值域都含 "conditional",光认 .st 分不清是哪一列, + 加 .dst / .rec 两个字段级修饰类各自配色(**原样照抄目标件 .st.ok/.miss/.unknown/.cond + 四条声明**,只是同一份颜色现在要接两条不同的人读文案)。 */ +${badgeCss('.st.dst', [ + ['match', 'MATCH', OK], + ['mismatch', 'MISMATCH', DANGER], + ['unknown', 'UNKNOWN', AMBER], + ['conditional', 'CONDITIONAL', 'color: var(--ledger); background: var(--ledger-soft); border-color: var(--ledger-line);'], +])} +${badgeCss('.st.rec', [ + ['recommended', '推荐', OK], + ['conditional', '条件推荐', 'color: var(--ledger); background: var(--ledger-soft); border-color: var(--ledger-line);'], + ['alternate', '备选', AMBER], + ['not_recommended', '不推荐', DANGER], +])} +/* + * 风险等级(原样照抄目标件 .risk.low/.mid/.hi 三条声明)——加 critical 一档:这一屏「各候选 + * 推荐等级」摘要读的是 substitution.relation.risk_level(声明了 low/medium/high/critical + * 四档),差异明细本身的 risk_level 只有三档,共用同一族选择器,多出的第四档不会撞车。 + */ +${badgeCss('.risk', [ + ['low', '低', 'color: var(--ok);'], + ['medium', '中', 'color: #8f6a12;'], + ['high', '高', 'color: var(--danger);'], + ['critical', '危急', 'color: var(--danger); font-weight: 900;'], +])} +/* + * 约束类型(硬/软)—— 目标件的差异明细表里这一列是纯文字,没有配色(数据工单-01 的 .ct.hard/ + * .ct.soft 才是这两个值真正的徽标声明,只是它长在另一份目标件里)。这里把那两条颜色声明 + * 原样搬过来当 v- 版(数值不改,只换了外壳类名,因为这一页的样式表里从未定义过 .ct)。 + */ +.con { display: inline-block; font-size: 11px; font-weight: 700; padding: 1px 8px; border-radius: 999px; border: 1px solid transparent; white-space: nowrap; } +${badgeCss('.con', [ + ['hard', '硬约束', DANGER], + ['soft', '软约束', MUTED], +])} +/* 替代类型 —— 目标件里也是纯文字,不配色,只补文案 */ +${badgeCss('.enumtxt', [ + ['pin_to_pin', 'Pin-to-Pin'], + ['functional', '功能替代'], + ['parametric', '参数替代'], + ['other', '其他'], +])} +`; + +/* ==================== 验收工单 02(评审放行与落账确认):徽标别名 ==================== */ +const BIND_ACC2 = ` +/* 这一屏四个枚举列(推荐等级 / 分析状态 / 需求状态 / 当前阶段)取值域两两不重叠,共用 .st 即可。 + 推荐等级、分析状态目标件里本就是 .st 徽标(原样照抄 .st.ok/.miss/.unknown/.cond 四条声明); + 需求状态 / 当前阶段目标件没有这两列,借同一套配色,不新配颜色。 */ +${badgeCss('.st', [ + ['recommended', '推荐', OK], + ['conditional', '条件推荐', 'color: var(--ledger); background: var(--ledger-soft); border-color: var(--ledger-line);'], + ['alternate', '备选', AMBER], + ['not_recommended', '不推荐', DANGER], + ['ai_draft', 'AI 草稿', AMBER], + ['fae_confirmed', 'FAE确认', OK], + ['pending_customer', '待客户验证', 'color: var(--ledger); background: var(--ledger-soft); border-color: var(--ledger-line);'], + ['customer_approved', '客户已批准', OK], + ['rejected', '不批准', DANGER], + ['void', '作废', MUTED], + ['pending', '待处理', MUTED], + ['responded', '已响应', 'color: var(--ledger); background: var(--ledger-soft); border-color: var(--ledger-line);'], + ['won', '已成交', OK], + ['abandoned', '已放弃', DANGER], + ['closed', '已关闭', MUTED], + ['assessing', '评估中', MUTED], + ['gate03', '提交 ACT-GATE-03', OK], +])} +/* 风险等级比验收 01 多一档 critical(P-11 主记录的 risk_level 声明了它,差异明细没有) */ +${badgeCss('.risk', [ + ['low', '低', 'color: var(--ok);'], + ['medium', '中', 'color: #8f6a12;'], + ['high', '高', 'color: var(--danger);'], + ['critical', '危急', 'color: var(--danger); font-weight: 900;'], +])} +/* 替代类型 —— 目标件里是纯文字,不配色,只补文案(与验收 01 同一套值域,各自页面各存一份) */ +${badgeCss('.enumtxt', [ + ['pin_to_pin', 'Pin-to-Pin'], + ['functional', '功能替代'], + ['parametric', '参数替代'], + ['other', '其他'], +])} +`; + +/** 三层壳照目标件:`
`,不再套 `.proto-root`/`.app-shell`/`.jc-stage` + * (那是 E04/I01 自己的视觉底约定,不是平台要求 —— ui-kit / view-render 从未引用过这几个类名; + * 目标件本身就是直接 `page > card`,搬版面就该原样搬这一层)。 + * 收件人 / 关联任务两格由引擎注入;目标件的「最迟交回」(`card.deadline`)本仓没有真数据源,不摆; + * 工单编号(`card.id`)换成本次评估案号 `eval_ref`。 + */ +const doc = (input: { css: string; alias: string; badge: string; hic?: string; tag: string; kicker: string; title: string; step: string; body: string; footTag: string }): string => + ` +
+
+
${input.badge}
+ ${input.hic ?? ''} +
+
${input.kicker}
+

${input.title}

+
收件人: · 关联任务:
+
+
+ ${input.tag} + ${input.step} +
+
+
${input.body}
+
+ ${input.kicker} · ${input.title} + ${input.footTag} · +
+
`; + +/* ==================== 内联 SVG 图标 —— 逐字节搬自「数据工单-01」目标件(它们是版面语言的一部分) ==================== */ +const HIC = + ''; +const ZIC_TASK = + ''; +const ZIC_TABLE = + ''; + +/* ==================== 通用绑定小工具 ==================== */ +const zone = (label: string, aside: string, icon = ''): string => `

${icon}【${label}】—— ${aside}

`; +const note = (items: readonly string[]): string => `
${items.map((p) => `

${p}

`).join('')}
`; +const criteria = (title: string, items: readonly string[]): string => + `
${title}
    ${items.map((i) => `
  • ${i}
    • `).join('')}
`; +const flow = (text: string): string => `
${text}
`; +const editGate = (address: string, label: string): string => `
+ ${label} + + + +
`; +const gapbar = (object: string, what: string): string => `
+ 还差 行${what}没填 —— 。按「编辑」开表,红框那几格就是要填的。补齐了才确认得了。 +
`; +const addrow = (address: string, label: string, hint: string): string => `
+ + ${hint} +
`; +/** 可改格:只读那一份留空,渲染器自动配孪生 ``(手写 input 会不填值,人一点编辑就是白框) */ +const cell = (col: string, cls = ''): string => ``; +/** 只读格:即便挂在可改的表里也不许被 `table.on` 藏起来 —— 目标件自己就有这条覆盖(`.jc-vcell.ro`) */ +const ro = (col: string, cls = ''): string => ``; +const select = (col: string, options: ReadonlyArray, required = false): string => + ``; +/** 枚举徽标(可改表里用,旁边挨着 `.jc-cell` 孪生件时要包一层 `.ro` 才不被编辑态藏起来) */ +const badge = (klass: string, col: string, wrapRo = false): string => { + const inner = ``; + return wrapRo ? `${inner}` : inner; +}; + +/* ==================== 局面 0 · 数据工单 P-08(搬自「数据工单-01」)==================== */ + +const P08_TABLE = `
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
#内部料号 internal_pn全链路统一基准,不可自由文本品牌 brand_name与制造商、供应商分开制造商 manufacturer_name与品牌不一致时分开记录规格描述 specification_description按原厂资料口径封装 package影响硬约束比对工艺 process_technology硬约束比较项生命周期 lifecycle_statusActive/NRND/EOL/停产/风险EOL/PCN eol_pcn_status通知/影响/生效时间Datasheet 引用 datasheet_refDatasheet 版本 datasheet_version与引用成对适配场景 application_scenarios判断实际适用性
${cell('internal_pn', 'mono')}${cell('brand_name')}${cell('manufacturer_name')}${cell('specification_description')}${cell('package', 'mono')}${cell('process_technology')}${badge('stx', 'lifecycle_status', true)}${select('lifecycle_status', [['active', 'Active'], ['nrnd', 'NRND'], ['eol', 'EOL'], ['discontinued', '停产'], ['risk', '风险']], true)}${cell('eol_pcn_status')}${cell('datasheet_ref', 'mono')}${cell('datasheet_version')}${cell('application_scenarios')}
`; + +/* + * 表 2 · 标准化参数集(P-08 子表 `parts.parameter`)—— 粒度与表 1 不同(一个参数一行, + * 行数不固定),不能塞进表 1 的一格(《统一方案》§六:重复明细用子表承载), + * 逐块搬自目标件《数据工单-01》的【创建什么 · 表 2】,`id="tbl2"` 沿用目标件自己的 + * 列宽声明(P08_CSS 里 `#tbl2 th:nth-child(n)` 那几条,不必在这里重复)。 + * 「说明」列是系统只读注释(目标件原话:「说明列为系统注释,无需填写」),不给 data-col。 + */ +const P08_PARAMS_TABLE = `
+ + + + + + + + + + + + + + + + + + +
#所属料号 internal_pn归属表 1 哪条记录参数名值单位约束(硬/软)说明
${cell('internal_pn', 'mono')}${cell('param_name')}${cell('param_value', 'mono')}${cell('param_unit')}${badge('ct', 'constraint_type', true)}${select('constraint_type', [['hard', '硬约束'], ['soft', '软约束']], true)}${ro('param_note')}
`; + +export const P08_MASTER_CREATE = doc({ + css: P08_CSS, + alias: BIND_P08, + badge: '数据', + hic: HIC, + tag: '数据工单', + kicker: 'SS02 · ACT-WORK-05 差异评估 · 数据工单 1/2', + title: '芯片主数据创建(P-08)', + step: '步骤 0.5 · 等待数据', + footTag: '工单类型:数据', + body: + zone('做什么', '批量创建 P-08 主数据记录', ZIC_TASK) + + note([ + '模板定位:本单是「数据工单」统一模板的实例——一单一类(可多条):目标台账 = 芯片主数据(P-08);字段即表头、每行一条新记录;标准化参数集是它的结构子表(表 2,一行一参数,按所属料号归属)。', + '触发原因:系统按内部料号查芯片主数据查无记录——是「完全没有」,不是字段缺失(那归执行工单)。', + 'AI 预填:上传了 datasheet 的料号 AI 已按资料预填,标着值的格子请核对;没上传的料号全部手填,同为合法路径。', + '纪律:必填列全齐才允许确认;确认后这批记录进本单草稿,放行时并入正式库并留痕(确认人 = 数据责任人);只建主数据,验证记录等事实类不在此建。', + ]) + + zone('创建什么 · 表 1', '主数据记录(每行一条,＊为必填列)', ZIC_TABLE) + + gapbar('parts_profile', '必填') + + editGate('parts.profile', `待建 条记录,点「编辑」核对预填、补齐空缺;「＋ 加一行」= 再建一条`) + + P08_TABLE + + addrow('parts.profile', '＋ 加一行(再建一条记录)', '新行的内部料号必须写(它是这一行的钥匙);其余必填列全部填写后才允许确认;删一行 = 该记录不建') + + `

${ZIC_TABLE}【创建什么 · 表 2】—— 标准化参数集(每行一个参数,按所属料号归属,＊必填)

` + + gapbar('parts_parameter', '必填') + + editGate('parts.parameter', `已铺 行参数(有 datasheet 的已按资料预填),点「编辑」核对修正;「＋ 加一行」补充未列出的参数`) + + P08_PARAMS_TABLE + + addrow('parts.parameter', '＋ 加一行(补充参数)', '所属料号 / 参数名 / 值 / 单位 / 约束类型齐全;「未披露」请直接写未披露,将进入 UNKNOWN 并挂验证任务;「说明」列为系统注释,无需填写') + + flow('提交 / 确认:本工单只承载内容;确认请在对话区的【执行卡】中进行。确认后活动自动从「等待数据」唤醒。'), +}); + +/* ==================== 局面 0′ · 数据工单 P-10(复用「数据工单-01」的样式与骨架,没有独立目标件)==================== */ + +const P10_TABLE = `
+ + + + + + + + + + + + + + + + + + + + + + + + +
#关联料号 internal_pn对应 P-08 那条记录资料序号 doc_seq同一料号下 01/02… 自己续资料类型 document_type品牌 brand_name资料标题 document_title资料版本 document_version文件链接 document_ref证据定位 citation_locator页码/章节/表格资料状态 document_status
${cell('internal_pn', 'mono')}${cell('doc_seq', 'mono')}${badge('stx', 'document_type', true)}${select('document_type', [['datasheet', 'Datasheet'], ['app_note', '应用笔记'], ['reference_design', '参考设计'], ['white_paper', '白皮书'], ['sample_doc', '样片资料'], ['commitment_letter', '承诺函'], ['other', '其他']], true)}${cell('brand_name')}${cell('document_title')}${cell('document_version')}${cell('document_ref', 'mono')}${cell('citation_locator')}${badge('stx', 'document_status', true)}${select('document_status', [['valid', '有效'], ['expired', '过期'], ['pending', '待核实'], ['void', '作废']], true)}
`; + +export const P10_DOCUMENT_CREATE = doc({ + css: P08_CSS, + alias: BIND_P08, + badge: '数据', + hic: HIC, + tag: '数据工单', + kicker: 'SS02 · ACT-WORK-05 差异评估 · 数据工单 2/2', + title: '原厂技术资料创建(P-10)', + step: '步骤 0.5 · 等待数据', + footTag: '工单类型:数据', + body: + zone('做什么', '为本单新建的料号登记原厂资料(P-10)', ZIC_TASK) + + note([ + '模板定位:与 P-08 同一套「数据工单」统一模板——目标台账 = 原厂技术资料库(P-10);一份资料一行,同一料号多份资料序号 01/02… 自己续。', + '触发原因:按内部料号查原厂技术资料库查无记录(P-08 那张先确认过,这一批料号才会走到这里)。', + '为什么要它:差异明细的证据引用要指到具体资料的版本与页码——没有这一行,结论就追溯不到来源。', + ]) + + zone('创建什么', '资料记录(每行一条,＊为必填列)', ZIC_TABLE) + + gapbar('parts_document', '必填') + + editGate('parts.document', `待建 条资料记录,点「编辑」补齐`) + + P10_TABLE + + addrow('parts.document', '＋ 加一行(再登记一份资料)', '关联料号与序号是这一行的钥匙,新行都要写;必填列全齐才允许确认;删一行 = 该资料不建') + + flow('提交 / 确认:本工单只承载内容;确认请在对话区的【执行卡】中进行。'), +}); + +/* ==================== 局面 1 · 评估输入清单(搬自「执行工单-01」)==================== */ + +const PN_CHECK_TABLE = `
+ + + + + + + + + + + + + + +
#料号角色在库状态备注 / 放弃原因
${ro('internal_pn', 'mono')}${badge('st', 'exists_status', true)}${ro('note')} ${ro('abandon_reason')}
`; + +const GAP_TABLE = `
+ + + + + + + + + + + + + + + + + + +
#键输入项来源状态绑定值 / 缺口说明补充内容
${cell('item_key', 'mono')}${cell('input_item')}${cell('source_ledger', 'mono')}${select('status', [['gap', '待补'], ['default', '默认·可改'], ['ok', '齐备']], true)}${badge('st', 'status')}${cell('detail')}${cell('supplement')}
`; + +export const EVAL_INPUT_LIST = doc({ + css: EXEC_CSS, + alias: BIND_EXEC, + badge: '执行', + tag: '执行工单', + kicker: 'SS02 · ACT-WORK-05 差异评估 · 执行工单 1/1', + title: '评估输入与资料补齐确认', + step: '步骤 1/5 · 建立评估上下文', + footTag: '工单类型:执行', + body: + zone('做什么', '启动 4 项已绑定,其余信息在工单里补齐') + + note([ + 'AI 已完成:系统已按启动传入的 4 项完成绑定——客户、客户需求(新建 P-01 · 版本 V1)、原 PN、候选 PN(数组,逐个评估)——并生成输入快照。', + '需要你补齐:启动时未收的信息(应用场景、BOM 位)直接在下表补;默认值(替代类型 / 规则版本 / 负责人期限)可确认可改。本单缺口只覆盖「有而不全」;「完全没有」(料号不在库)已由数据工单创建。未补齐的缺口项将按 UNKNOWN 进入差异评估。', + ]) + + zone('料号存在性核对', '只读参考 · 与下表「补充内容」互不冲突') + + PN_CHECK_TABLE + + zone('交回什么', '评估输入清单(已绑定项照实核对,缺口项补齐,＊为必填)') + + gapbar(`${D}_input_gap`, '补充内容') + + editGate(`${D}.input_gap`, `还有 项待补 / 待确认,点「编辑」在「补充内容」列填入 —— 已绑定那几行的「输入项/来源/绑定值」抄的是启动入参,发现记录本身有误请退回触发方重新启动,不要在这里改`) + + GAP_TABLE + + addrow(`${D}.input_gap`, '＋ 加一行(补充资料项)', '新行的「键」必须写(它是这一行的钥匙,写一个英文短名,如 thermal_note);「输入项」与「补充内容」也是必填;删一行 = 该输入项不适用;补不了的写「留 UNKNOWN」或「挂验证任务」') + + flow( + '审批 / 提交:本工单只承载内容;「提交」请在对话区的【执行卡】中进行。提交后去向:进入步骤 2 · AI 读取与标准化,仍缺失的项将按 UNKNOWN 进入差异评估。注意:启动参数如有误,需退回触发方修订后重新触发,本单不可改。', + ), +}); + +/* ==================== 局面 2 · 差异评估结论审核(搬自「验收工单-01」)==================== */ + +const RELATION_SUMMARY_TABLE = `
+ + + + + + + + + + + + + + + + + + +
#候选料号替代类型推荐等级风险等级推荐理由差异摘要
${badge('st rec', 'recommendation_level')}${badge('risk', 'risk_level')}
`; + +const DIFFERENCE_ITEM_TABLE = `
+ + + + + + + + + + + + + +
#参数项 parameter_name原 PN 值 original_value候选 PN 值 candidate_value单位 parameter_unit约束类型 constraint_type结论 difference_status风险等级证据引用 evidence_refAI 置信度
${badge('st dst', 'difference_status')}${badge('risk', 'risk_level')}
`; + +export const DIFFERENCE_REVIEW = doc({ + css: ACC1_CSS, + alias: BIND_ACC1, + badge: '验收', + tag: '验收工单', + kicker: 'SS02 · ACT-WORK-05 差异评估 · 验收工单 1/2', + title: '差异评估结论审核', + step: '步骤 3~4/5 · 逐项差异评估 + FAE/RI 审核', + footTag: '工单类型:验收', + body: + zone('AI 结论说明', '结论是怎么算出来的') + + note([ + 'AI 已完成的计算:按 GOV 评估规则(锁定版本 ),对原 PN 与每个候选逐项比对,产出四态结论——MATCH / MISMATCH / UNKNOWN / CONDITIONAL,并给出风险等级、证据引用与置信度。差异明细 = P-11 差异明细子表(一条参数差异一条记录);当前为 AI 草稿,FAE 审核通过前不落账。评估参数可能含本次数据工单创建的主数据(确认人背书;未附 datasheet 的参数项会显式标注「人工录入」)。', + ]) + + criteria('判断这份差异评估结论是否可信,请逐项核对', [ + '关键参数差异均有明确状态:逐项结论无漏项,每个参数都有四态之一的判定;', + 'UNKNOWN 项均有去向:每个 UNKNOWN 都挂了验证任务或补来源动作,不允许悬空;', + '证据链完整:每项结论可追溯至 P-08 / P-10 / P-06 的具体记录,或本单数据工单的创建记录(标注:人工录入);', + '硬约束项未被自动判 MATCH:封装 / 工艺等硬约束未经证据支持不得判 MATCH。', + ]) + + zone('各候选推荐等级', '只读展示(P-11 主记录草稿,一个候选一条)') + + RELATION_SUMMARY_TABLE + + zone('AI 产出的差异明细', '只读展示(P-11 差异明细子表草稿 · 一条参数一条记录 difference_item_id)') + + DIFFERENCE_ITEM_TABLE + + flow( + '审批:本工单只承载内容;「通过 / 驳回」请在对话区的【验收卡】中进行。审核意见与补充条件写入 P-06(验证要求 verification_requirement);通过后去向:进入步骤 5 · 评审放行与落账确认。', + ), +}); + +/* ==================== 局面 3 · 评审放行与落账确认(搬自「验收工单-02」)==================== */ + +/** 字段:值 两列表 —— 逐字节搬自目标件「拟写 P-11」「拟回写 P-01」的版式(一行一个字段), + * 用 `data-rows` 包一整张小表当行模版,一个候选 / 一条需求各重复出一份,天然支持多候选。 */ +const P11_FIELD_TABLE = `
+ + + + + + + + + + + + + + + + +
#字段拟写入值
替代类型 substitution_type
原内部料号 original_internal_pn
候选内部料号 candidate_internal_pn
推荐等级 recommendation_level${badge('st', 'recommendation_level')} (枚举:推荐 / 条件推荐 / 备选 / 不推荐,四态之一)
推荐理由 recommendation_reason
差异摘要 difference_summary
替代分析报告 analysis_report_ref
分析状态 analysis_status${badge('st', 'analysis_status')} (枚举:AI草稿 / FAE确认 / 待客户验证 / 客户已批准 / 不批准 / 作废)
客户批准状态 customer_approval_status未提交 (由审批流程维护,本活动不产生)
风险等级 risk_level${badge('risk', 'risk_level')}
验证要求 verification_requirement
证据可信度 confidence_score
差异规则版本 rule_version
`; + +const P01_FIELD_TABLE = `
+ + + + + + + + + +
#字段拟写入值
风险等级 risk_level${badge('risk', 'risk_level')}
验证要求 verification_requirement
输出链接 output_ref
下一步动作 next_action
当前阶段 current_stage${badge('st', 'current_stage')}
需求状态 request_status${badge('st', 'request_status')}
`; + +export const LANDING_CONFIRM = doc({ + css: ACC2_CSS, + alias: BIND_ACC2, + badge: '验收', + tag: '验收工单', + kicker: 'SS02 · ACT-WORK-05 差异评估 · 验收工单 2/2', + title: '评审放行与落账确认', + step: '步骤 5/5 · 提交 ACT-GATE-03', + footTag: '工单类型:验收', + body: + zone('AI 结论说明', '本单确认什么') + + note([ + '本活动以 ACT-GATE-03 评审放行为终点。本单确认拟落账内容:评估结论层写 P-11 替代关系主记录(替代类型 / 原内部料号 / 候选内部料号 / 推荐等级 / 推荐理由 / 差异摘要 / 替代分析报告 / 分析状态 / 风险等级 / 验证要求 / 证据可信度 / 差异规则版本),需求状态回写 P-01(风险等级 / 验证要求 / 输出链接 / 下一步动作 / 当前阶段)。客户批准不属于本活动——客户批准状态由审批流程维护,本单只写分析层(分析状态 = FAE 确认),customer_approval_status 保持「未提交」,不由差异评估产生。', + ]) + + criteria('放行与落账前,请逐项核对', [ + '推荐等级与差异明细一致:差异明细中存在 UNKNOWN / CONDITIONAL 时,推荐等级不得给「推荐」;', + '分析状态与客户批准状态分离:本单只写分析层(分析状态 = FAE 确认),客户批准状态保持「未提交」;', + 'GOV 规则版本已锁定:规则版本随结论一并落账;', + '回写 P-01 字段完整:风险等级、验证要求、输出链接、下一步动作、当前阶段五项齐全。', + ]) + + zone('拟写 P-11 · 替代关系主记录', '只读展示') + + P11_FIELD_TABLE + + zone('拟回写 P-01 · 需求状态', '只读展示') + + P01_FIELD_TABLE + + flow( + '审批:本工单只承载内容;「通过 / 驳回」请在对话区的【验收卡】中进行。通过后去向:在对话区卡提交 ACT-GATE-03 评审放行;放行后结论供 ACT-WORK-08 证据归集消费。', + ), +}); diff --git a/activities/part-substitution-assessment/src/views/target-style.ts b/activities/part-substitution-assessment/src/views/target-style.ts new file mode 100644 index 0000000..3026657 --- /dev/null +++ b/activities/part-substitution-assessment/src/views/target-style.ts @@ -0,0 +1,336 @@ +/** + * ACT-WORK-05 差异评估的四份目标件样式表 —— **机械抽取,一个数值都不许改** + * (《HTML报告生成规范》§7:有目标件时「搬」,不要「照着做」;样式表整段搬,标记逐块搬)。 + * + * 来源(`docs/SS02-ACT-WORK-05-html/`): + * · `P08_CSS` ← `ACT-WORK-05-数据工单-01-芯片主数据创建.html` 的两段 `` 之间的原文,再拿抽出来的内容包回 + * `` 与源文件同一行区间做 `diff`,四份全部「零差异」——过程写在 + * task-5-report.md,这里不重复贴证据。 + * + * 这份文件只装**目标件自己的样式**,不装平台绑定用的开关(三态占位、缺项红带、 + * `data-class-of` 的 `v-*` 别名这类)——那些是本活动自己加出来的东西,活在 + * `report.ts` 的 `BIND_CSS_*` 常量里,两处不要混。 + */ + +export const P08_CSS = ` +:root{ + --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e; + --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb; + --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff; + --data:#3370ff; --data-soft:#e1eaff; --data-line:#c3d6ff; + --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9; + --mono:"SF Mono",Menlo,Consolas,monospace; +} +*{box-sizing:border-box} +html,body{margin:0;padding:0} +body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased} +.page{margin:0;padding:0} +.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none} +.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#f0f5ff 0%,#fff 55%,#eef4ff 100%)} +.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--data);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(51,112,255,.25)} +.tit{flex:1;min-width:0} +.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700} +.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3} +.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px} +.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none} +.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--data);background:var(--data-soft);border:1px solid var(--data-line)} +.step{font-size:12px;color:var(--ink-3)} +.deadline{font-size:12px;color:var(--ink-3)} +.deadline b{color:var(--danger)} +.card-bd{padding:20px 22px} +.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px} +.zone b{color:var(--ink-3)} +.note{border:1px solid var(--line);border-left:3px solid var(--data);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px} +.note p{margin:0 0 6px;font-size:13px;color:var(--ink-2)} +.note p:last-child{margin-bottom:0} +.note b{color:var(--ink)} +.note .done{color:var(--ok);font-weight:700} +.note .need{color:var(--data);font-weight:700} +.jc-editgate{display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin:14px 0 10px;padding:9px 12px;border-radius:9px;background:var(--soft);border:1px solid var(--line-soft);font-size:12px;color:var(--ink-3)} +.jc-editgate-t{flex:1 1 auto;min-width:0} +.jc-editgate-t b{color:var(--ink-2);font-weight:700} +.jc-egbtn{flex:none;display:inline-flex;align-items:center;gap:5px;cursor:pointer;border:1px solid var(--line);border-radius:7px;padding:6px 13px;font:inherit;font-size:12px;font-weight:700;color:var(--ink-2);background:#fff;transition:border-color .16s,color .16s,background .16s} +.jc-egbtn:hover{border-color:var(--brand);color:var(--brand)} +.jc-egbtn.save{color:#fff;background:var(--data);border-color:var(--data)} +.jc-egbtn.save:hover{filter:brightness(1.06);color:#fff} +.jc-editgate .eg-cancel,.jc-editgate .eg-save{display:none} +.jc-editgate.on{background:var(--brand-wash);border-color:var(--data-line);color:#1e40af} +.jc-editgate.on .eg-open{display:none} +.jc-editgate.on .eg-cancel,.jc-editgate.on .eg-save{display:inline-flex} +.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden} +table{width:100%;border-collapse:collapse;font-size:12.5px} +th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.03em;font-weight:800;color:var(--ink-3);padding:9px 10px;border-bottom:1px solid var(--line)} +th.req::after{content:" ＊";color:var(--danger);font-size:11px} +td{padding:8px 10px;border-bottom:1px solid var(--line-soft);vertical-align:middle} +tr:last-child td{border-bottom:0} +td.rn{position:relative;width:38px;white-space:nowrap;font-family:var(--mono);font-size:11px;color:var(--ink-4);text-align:center} +.jc-vcell{display:block;font-size:12.5px;color:var(--ink);line-height:1.5;overflow-wrap:anywhere} +.jc-vcell.mono{font-family:var(--mono);font-size:11.5px;color:var(--ink-2)} +.jc-cell{display:none;width:100%;min-width:60px;border:1px solid var(--line);border-radius:6px;padding:6px 8px;font:inherit;font-size:12.5px;color:var(--ink);background:#fff} +.jc-cell.mono{font-family:var(--mono);font-size:11.5px} +.jc-cell:focus{border-color:var(--brand);box-shadow:0 0 0 3px var(--brand-wash);outline:none} +table.on td>.jc-vcell{display:none} +table.on td>.jc-cell{display:block} +td.rn .jc-rowdel{display:none;width:22px;height:22px;margin:0 auto;cursor:pointer;border:1px solid var(--line);border-radius:6px;padding:0;font:inherit;font-size:14px;line-height:1;color:var(--ink-3);background:#fff} +td.rn .jc-rowdel:hover{border-color:var(--danger);color:var(--danger);background:var(--danger-soft)} +table.on td.rn .jc-rn-num{display:none} +table.on td.rn .jc-rowdel{display:block} +.jc-addrow{display:none;margin:8px 0 0;padding:8px 12px;border-radius:9px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.jc-addrow.show{display:flex;align-items:center;gap:8px} +.jc-addrow button{cursor:pointer;border:1px solid var(--brand-soft);border-radius:7px;padding:5px 12px;font:inherit;font-size:12px;font-weight:700;color:var(--brand-deep);background:var(--brand-wash)} +.jc-addrow button:hover{background:var(--brand-soft)} +.jc-addrow em{font-style:normal;font-size:11.5px;color:var(--ink-4)} +.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.flow b{color:var(--ink)} +.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px} +@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}} +/* 补充：数据工单专用标识（仅追加，不改动基件样式） */ +.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)} +.pre{font-style:normal;font-size:10.5px;font-weight:800;color:var(--data);background:var(--data-soft);border:1px solid var(--data-line);border-radius:999px;padding:0 7px;margin-left:6px;white-space:nowrap} +table.on td>.pre{display:none} +.ct{display:inline-block;font-size:11px;font-weight:700;padding:1px 8px;border-radius:999px;border:1px solid transparent;white-space:nowrap} +.ct.hard{color:var(--danger);background:var(--danger-soft);border-color:#f3b9b5} +.ct.soft{color:var(--ink-3);background:#eef1f6;border-color:var(--line)} +.tbl-gap{margin-top:18px} +/* ===== 视觉补充段 v3（通用批量模板：字段即表头、每行一条；不改基件样式与 JS 钩子） ===== */ +.hic{flex:none;width:26px;height:26px;color:var(--data)} +.zic{width:14px;height:14px;color:var(--ink-3);vertical-align:-2px;margin-right:3px} +/* 表头内字段说明（第二行小字） */ +.thd{display:block;font-size:10px;font-weight:600;color:var(--ink-4);letter-spacing:0;margin-top:1px;line-height:1.4} +/* 表 1：字段即表头，内容多列，允许横向滚动 */ +#tbl1{min-width:1240px} +#tbl1 .jc-vcell{display:inline} +/* 表 2 列宽 */ +#tbl2 th:nth-child(2){width:150px} +#tbl2 th:nth-child(3){width:18%} +#tbl2 th:nth-child(4){width:14%} +#tbl2 th:nth-child(5){width:8%;text-align:center;white-space:nowrap} +#tbl2 th:nth-child(6){width:13%;text-align:center;white-space:nowrap} +#tbl2 td:nth-child(5),#tbl2 td:nth-child(6){text-align:center;white-space:nowrap} +/* 说明列（只读注释，编辑态保持可见） */ +.desc{color:var(--ink-3);font-size:12px;line-height:1.5} +table.on td>.jc-vcell.ro{display:block} +.tbl-wrap{overflow-x:auto} +@media (prefers-reduced-motion: reduce){*{animation:none!important;transition:none!important}} +`; + +export const EXEC_CSS = ` +:root{ + --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e; + --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb; + --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff; + --human:#a9711e; --human-soft:#f6ecd8; --human-line:#e6d3a8; + --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9; + --mono:"SF Mono",Menlo,Consolas,monospace; +} +*{box-sizing:border-box} +html,body{margin:0;padding:0} +body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased} +.page{margin:0;padding:0} +.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none} +.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#fffaf1 0%,#fff 55%,#fbf6ea 100%)} +.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--human);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(169,113,30,.25)} +.tit{flex:1;min-width:0} +.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700} +.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3} +.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px} +.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none} +.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--human);background:var(--human-soft);border:1px solid var(--human-line)} +.step{font-size:12px;color:var(--ink-3)} +.deadline{font-size:12px;color:var(--ink-3)} +.deadline b{color:var(--danger)} +.card-bd{padding:20px 22px} +.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px} +.zone b{color:var(--ink-3)} +.note{border:1px solid var(--line);border-left:3px solid var(--human);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px} +.note p{margin:0;font-size:13px;color:var(--ink-2)} +.note b{color:var(--ink)} +.note .done{color:var(--ok);font-weight:700} +.note .need{color:var(--human);font-weight:700} +.jc-editgate{display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin:14px 0 10px;padding:9px 12px;border-radius:9px;background:var(--soft);border:1px solid var(--line-soft);font-size:12px;color:var(--ink-3)} +.jc-editgate-t{flex:1 1 auto;min-width:0} +.jc-editgate-t b{color:var(--ink-2);font-weight:700} +.jc-egbtn{flex:none;display:inline-flex;align-items:center;gap:5px;cursor:pointer;border:1px solid var(--line);border-radius:7px;padding:6px 13px;font:inherit;font-size:12px;font-weight:700;color:var(--ink-2);background:#fff;transition:border-color .16s,color .16s,background .16s} +.jc-egbtn:hover{border-color:var(--brand);color:var(--brand)} +.jc-egbtn.save{color:#fff;background:var(--human);border-color:var(--human)} +.jc-egbtn.save:hover{filter:brightness(1.06);color:#fff} +.jc-editgate .eg-cancel,.jc-editgate .eg-save{display:none} +.jc-editgate.on{background:var(--human-soft);border-color:var(--human-line);color:#7c4a12} +.jc-editgate.on .eg-open{display:none} +.jc-editgate.on .eg-cancel,.jc-editgate.on .eg-save{display:inline-flex} +.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden} +table{width:100%;border-collapse:collapse;font-size:12.5px} +th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.03em;font-weight:800;color:var(--ink-3);padding:9px 10px;border-bottom:1px solid var(--line)} +th.req::after{content:" ＊";color:var(--danger);font-size:11px} +td{padding:8px 10px;border-bottom:1px solid var(--line-soft);vertical-align:middle} +tr:last-child td{border-bottom:0} +td.rn{position:relative;width:38px;white-space:nowrap;font-family:var(--mono);font-size:11px;color:var(--ink-4);text-align:center} +.jc-vcell{display:block;font-size:12.5px;color:var(--ink);line-height:1.5;overflow-wrap:anywhere} +.jc-vcell.mono{font-family:var(--mono);font-size:11.5px;color:var(--ink-2)} +.jc-cell{display:none;width:100%;min-width:60px;border:1px solid var(--line);border-radius:6px;padding:6px 8px;font:inherit;font-size:12.5px;color:var(--ink);background:#fff} +.jc-cell.mono{font-family:var(--mono);font-size:11.5px} +.jc-cell:focus{border-color:var(--brand);box-shadow:0 0 0 3px var(--brand-wash);outline:none} +table.on td>.jc-vcell{display:none} +table.on td>.jc-cell{display:block} +td.rn .jc-rowdel{display:none;width:22px;height:22px;margin:0 auto;cursor:pointer;border:1px solid var(--line);border-radius:6px;padding:0;font:inherit;font-size:14px;line-height:1;color:var(--ink-3);background:#fff} +td.rn .jc-rowdel:hover{border-color:var(--danger);color:var(--danger);background:var(--danger-soft)} +table.on td.rn .jc-rn-num{display:none} +table.on td.rn .jc-rowdel{display:block} +.jc-addrow{display:none;margin:8px 0 0;padding:8px 12px;border-radius:9px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.jc-addrow.show{display:flex;align-items:center;gap:8px} +.jc-addrow button{cursor:pointer;border:1px solid var(--brand-soft);border-radius:7px;padding:5px 12px;font:inherit;font-size:12px;font-weight:700;color:var(--brand-deep);background:var(--brand-wash)} +.jc-addrow button:hover{background:var(--brand-soft)} +.jc-addrow em{font-style:normal;font-size:11.5px;color:var(--ink-4)} +.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.flow b{color:var(--ink)} +.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px} +@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}} +/* 补充：评估输入清单状态标识（仅追加，不改动基件样式） */ +.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)} +.st{display:inline-block;font-size:11px;font-weight:700;padding:1px 8px;border-radius:999px;border:1px solid transparent;white-space:nowrap} +.st.bound{color:var(--ink-3);background:#eef1f6;border-color:var(--line)} +.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#c9ecc2} +.st.miss{color:var(--human);background:var(--human-soft);border-color:var(--human-line)} +.st.def{color:var(--brand-deep);background:var(--brand-wash);border-color:var(--brand-soft)} +tr.ro td{background:var(--soft)} +table.on td>.jc-vcell.ro{display:block} +`; + +export const ACC1_CSS = ` +:root{ + --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e; + --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb; + --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff; + --ledger:#b23a2e; --ledger-soft:#f7e4e0; --ledger-line:#ecc5bd; + --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9; + --mono:"SF Mono",Menlo,Consolas,monospace; +} +*{box-sizing:border-box} +html,body{margin:0;padding:0} +body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased} +.page{margin:0;padding:0} +.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none} +.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#fdf3f1 0%,#fff 55%,#fbf2f0 100%)} +.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--ledger);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(178,58,46,.25)} +.tit{flex:1;min-width:0} +.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700} +.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3} +.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px} +.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none} +.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--ledger);background:var(--ledger-soft);border:1px solid var(--ledger-line)} +.step{font-size:12px;color:var(--ink-3)} +.deadline{font-size:12px;color:var(--ink-3)} +.deadline b{color:var(--danger)} +.card-bd{padding:20px 22px} +.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px} +.zone b{color:var(--ink-3)} +.note{border:1px solid var(--line);border-left:3px solid var(--ledger);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px} +.note p{margin:0;font-size:13px;color:var(--ink-2)} +.note b{color:var(--ink)} +.criteria{border:1px solid var(--ledger-line);border-radius:10px;background:var(--ledger-soft);padding:13px 16px;margin-bottom:18px} +.criteria .c-title{font-size:11px;font-weight:800;letter-spacing:.08em;color:var(--ledger);margin-bottom:7px} +.criteria ul{margin:0;padding-left:18px;font-size:12.5px;color:var(--ink-2)} +.criteria li{margin:4px 0} +.criteria b{color:var(--ink)} +.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden} +table{width:100%;border-collapse:collapse;font-size:13px} +th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.05em;font-weight:800;color:var(--ink-3);padding:9px 12px;border-bottom:1px solid var(--line)} +td{padding:11px 12px;border-bottom:1px solid var(--line-soft);vertical-align:top} +tr:last-child td{border-bottom:0} +.num{font-family:var(--mono);color:var(--ink-4);white-space:nowrap} +.cust{font-weight:700} +.prio{font-family:var(--mono);font-weight:800} +.prio.hi{color:var(--danger)} +.prio.mid{color:var(--ink-2)} +.reason{font-size:12.5px;color:var(--ink-2)} +.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.flow b{color:var(--ink)} +.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px} +@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}} +/* 补充：四态结论 pill 与风险等级（仅追加，不改动基件样式） */ +.st{display:inline-block;padding:1px 9px;border-radius:999px;font-size:11px;font-weight:800;letter-spacing:.04em;font-family:var(--mono);white-space:nowrap;border:1px solid transparent} +.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#bfe6b4} +.st.miss{color:var(--danger);background:var(--danger-soft);border-color:#f3b9b5} +.st.unknown{color:#8f6a12;background:#fdf3d7;border-color:#ecd9a0} +.st.cond{color:var(--ledger);background:var(--ledger-soft);border-color:var(--ledger-line)} +.risk{font-weight:800;font-size:12.5px} +.risk.low{color:var(--ok)} +.risk.mid{color:#8f6a12} +.risk.hi{color:var(--danger)} +.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)} +`; + +export const ACC2_CSS = ` +:root{ + --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e; + --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb; + --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff; + --ledger:#b23a2e; --ledger-soft:#f7e4e0; --ledger-line:#ecc5bd; + --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9; + --mono:"SF Mono",Menlo,Consolas,monospace; +} +*{box-sizing:border-box} +html,body{margin:0;padding:0} +body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased} +.page{margin:0;padding:0} +.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none} +.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#fdf3f1 0%,#fff 55%,#fbf2f0 100%)} +.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--ledger);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(178,58,46,.25)} +.tit{flex:1;min-width:0} +.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700} +.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3} +.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px} +.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none} +.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--ledger);background:var(--ledger-soft);border:1px solid var(--ledger-line)} +.step{font-size:12px;color:var(--ink-3)} +.deadline{font-size:12px;color:var(--ink-3)} +.deadline b{color:var(--danger)} +.card-bd{padding:20px 22px} +.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px} +.zone b{color:var(--ink-3)} +.note{border:1px solid var(--line);border-left:3px solid var(--ledger);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px} +.note p{margin:0;font-size:13px;color:var(--ink-2)} +.note b{color:var(--ink)} +.criteria{border:1px solid var(--ledger-line);border-radius:10px;background:var(--ledger-soft);padding:13px 16px;margin-bottom:18px} +.criteria .c-title{font-size:11px;font-weight:800;letter-spacing:.08em;color:var(--ledger);margin-bottom:7px} +.criteria ul{margin:0;padding-left:18px;font-size:12.5px;color:var(--ink-2)} +.criteria li{margin:4px 0} +.criteria b{color:var(--ink)} +.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden} +table{width:100%;border-collapse:collapse;font-size:13px} +th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.05em;font-weight:800;color:var(--ink-3);padding:9px 12px;border-bottom:1px solid var(--line)} +td{padding:11px 12px;border-bottom:1px solid var(--line-soft);vertical-align:top} +tr:last-child td{border-bottom:0} +.num{font-family:var(--mono);color:var(--ink-4);white-space:nowrap} +.cust{font-weight:700} +.prio{font-family:var(--mono);font-weight:800} +.prio.hi{color:var(--danger)} +.prio.mid{color:var(--ink-2)} +.reason{font-size:12.5px;color:var(--ink-2)} +.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)} +.flow b{color:var(--ink)} +.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px} +@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}} +/* 补充：推荐等级 pill 与状态强调（仅追加，不改动基件样式） */ +.st{display:inline-block;padding:1px 9px;border-radius:999px;font-size:11px;font-weight:800;letter-spacing:.04em;font-family:var(--mono);white-space:nowrap;border:1px solid transparent} +.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#bfe6b4} +.st.miss{color:var(--danger);background:var(--danger-soft);border-color:#f3b9b5} +.st.unknown{color:#8f6a12;background:#fdf3d7;border-color:#ecd9a0} +.st.cond{color:var(--ledger);background:var(--ledger-soft);border-color:var(--ledger-line)} +.risk{font-weight:800;font-size:12.5px} +.risk.mid{color:#8f6a12} +.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)} +.tbl-gap{margin-top:18px} +`; diff --git a/api-report/apps/api/src/modules/org/port.d.ts b/api-report/apps/api/src/modules/org/port.d.ts index f0b9ff1..8aa20ec 100644 --- a/api-report/apps/api/src/modules/org/port.d.ts +++ b/api-report/apps/api/src/modules/org/port.d.ts @@ -12,6 +12,8 @@ export type VerifiedClaims = { readonly sub: string; readonly preferred_username: string; readonly name?: string; + readonly given_name?: string; + readonly family_name?: string; readonly email?: string; readonly realm_access?: { readonly roles?: readonly string[]; diff --git a/api-report/packages/contracts/src/api/workbench.d.ts b/api-report/packages/contracts/src/api/workbench.d.ts index b120b40..4e61916 100644 --- a/api-report/packages/contracts/src/api/workbench.d.ts +++ b/api-report/packages/contracts/src/api/workbench.d.ts @@ -891,6 +891,7 @@ export declare const taskDetailSchema: z.ZodObject<{ cols: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional, z.ZodLiteral<2>]>>; }, z.core.$strip>>; submitLabel: z.ZodOptional; + gateLedgers: z.ZodOptional>; gate: z.ZodOptional { + const found = FIRST_PARTY_TOOLS.find(([n]) => n === name); + if (found === undefined) throw new Error(`没有工具 ${name}`); + return found[1]; +}; +/** ToolHandler 的入参形状见 `apps/api/src/modules/toolbox/internal/adapter/toolbox-store.ts`:纯工具不用连接目标 */ +const call = async (name: string, input: Record) => { + const out = await handler(name)({ input, connection: {}, operation: undefined, idempotencyKey: undefined }); + if (!out.ok) throw new Error(`工具失败:${JSON.stringify(out)}`); + return out.output as Record; +}; + +type Item = { parameterName: string; compareResult: string; differenceStatus: string; riskLevel: string }; +type Result = { candidateInternalPn: string; items: Item[]; counts: Record }; + +const pair = (parameterName: string, originalValue: string, candidateValue: string, constraintType: 'hard' | 'soft', extra: Record = {}) => ({ + parameterName, + originalValue, + candidateValue, + constraintType, + evidenceRef: 'P-08 · P-10 Rev H', + ...extra, +}); + +describe('边界上的 null:模型给 null 不该把工具打崩', () => { + it('**requirement / evidenceRef 给 null 照常算**(2026-08-27 W05 e2e 实测:模型写 `requirement: null` 而不是省掉,`null.trim()` 当场崩,整次调用记成「行动被拒」)', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [ + { + candidateInternalPn: 'LM2596S-ADJ', + pairs: [ + { parameterName: '输出电压', originalValue: '5.0', candidateValue: '1.23~37', constraintType: 'hard', unit: 'V', requirement: null, evidenceRef: null }, + { parameterName: '输入电压范围', originalValue: '4.5~40', candidateValue: '4.5~40', constraintType: 'hard', unit: 'V', requirement: '>= 40', evidenceRef: 'P-10 Rev H' }, + ], + }, + ], + }); + const items = (out as { results: Array<{ items: Array<{ parameterName: string; differenceStatus: string }> }> }).results[0]!.items; + expect(items.find((i) => i.parameterName === '输出电压')?.differenceStatus).toBe('conditional'); + expect(items.find((i) => i.parameterName === '输入电压范围')?.differenceStatus).toBe('match'); + }); + + it('硬约束的 evidenceRef 给 null = 没给证据 → 不判 MATCH,退成 CONDITIONAL', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [ + { + candidateInternalPn: 'X', + pairs: [{ parameterName: '输出电压', originalValue: '5.0', candidateValue: '5.0', constraintType: 'hard', evidenceRef: null }], + }, + ], + }); + expect((out as { results: Array<{ items: Array<{ differenceStatus: string }> }> }).results[0]!.items[0]!.differenceStatus).toBe('conditional'); + }); +}); + +describe('compare-parameters:逐参数四态', () => { + it('候选温域更宽 → covers → MATCH 低风险;固定 vs 可调 → configurable → CONDITIONAL;未披露 → UNKNOWN', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [ + { + candidateInternalPn: 'XL2596S-5.0', + pairs: [ + pair('工作温度', '-40~+85', '-40~+125', 'hard', { unit: '℃' }), + pair('输出电压', '5.0', '5.0', 'hard', { unit: 'V' }), + pair('使能阈值', '1.4', '未披露', 'hard', { unit: 'V' }), + pair('静态电流', '5', '4.2', 'soft', { unit: 'mA' }), + ], + }, + { + candidateInternalPn: 'LM2596S-ADJ', + pairs: [pair('输出电压', '5.0', '1.23~37', 'hard', { unit: 'V' })], + }, + ], + }); + const results = out['results'] as Result[]; + const a = results[0]!; + const b = results[1]!; + expect(out['ruleVersion']).toBe('R-2026.07'); + const by = (r: Result, name: string) => r.items.find((i) => i.parameterName === name); + expect(by(a, '工作温度')).toMatchObject({ compareResult: 'covers', differenceStatus: 'match', riskLevel: 'low' }); + expect(by(a, '输出电压')).toMatchObject({ compareResult: 'equal', differenceStatus: 'match' }); + expect(by(a, '使能阈值')).toMatchObject({ compareResult: 'unknown', differenceStatus: 'unknown', riskLevel: 'medium' }); + expect(by(a, '静态电流')).toMatchObject({ differenceStatus: 'conditional' }); // 软约束数值不同 → 条件 + expect(a.counts).toMatchObject({ match: 2, unknown: 1, conditional: 1, mismatch: 0, hardMismatch: 0 }); + expect(by(b, '输出电压')).toMatchObject({ compareResult: 'configurable', differenceStatus: 'conditional' }); + expect(b.counts['configurable']).toBe(1); + }); + + it('硬约束范围变窄 → MISMATCH 高风险;客户约束(requirement)不满足也是 MISMATCH', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [ + { + candidateInternalPn: 'CN-DCDC-32V', + pairs: [ + pair('输入电压范围', '4.5~40', '4.5~32', 'hard', { unit: 'V', requirement: '>= 40' }), + pair('封装', 'TO-263-5', 'TO-263-5', 'hard'), + ], + }, + ], + }); + const c = (out['results'] as Result[])[0]!; + expect(c.items[0]).toMatchObject({ compareResult: 'narrower', differenceStatus: 'mismatch', riskLevel: 'high' }); + expect(c.items[1]).toMatchObject({ compareResult: 'equal', differenceStatus: 'match' }); + expect(c.counts).toMatchObject({ mismatch: 1, hardMismatch: 1, match: 1 }); + }); + + it('硬约束相等但没有证据引用 → 不判 MATCH,降为 CONDITIONAL(硬约束项未经证据支持不得判 MATCH)', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [{ candidateInternalPn: 'X', pairs: [{ parameterName: '封装', originalValue: 'TO-263-5', candidateValue: 'TO-263-5', constraintType: 'hard' }] }], + }); + const x = (out['results'] as Result[])[0]!; + expect(x.items[0]).toMatchObject({ compareResult: 'equal', differenceStatus: 'conditional' }); + }); + + it('数值带单位/括号注记也认得:「5.0(固定)」「3A」「150 kHz」;生命周期按活跃度比', async () => { + const out = await call('part-substitution-assessment.compare-parameters', { + candidates: [{ candidateInternalPn: 'X', pairs: [pair('输出电压', '5.0(固定)', '5.0 V', 'hard'), pair('输出电流', '3A', '3', 'hard'), pair('开关频率', '150 kHz', '150', 'hard'), pair('生命周期', 'nrnd', 'active', 'soft')] }], + }); + const x = (out['results'] as Result[])[0]!; + // 生命周期不是数值:候选比原料更活(nrnd → active)算 covers → MATCH,替 NRND 料本就是为了这个 + expect(x.items.map((i) => i.differenceStatus)).toEqual(['match', 'match', 'match', 'match']); + expect(x.items[3]?.compareResult).toBe('covers'); + }); +}); + +describe('recommend:推荐等级四档', () => { + it('硬约束 MISMATCH → 不推荐;有 UNKNOWN → 条件推荐;只有 configurable → 备选;全 MATCH → 推荐', async () => { + const out = await call('part-substitution-assessment.recommend', { + candidates: [ + { candidateInternalPn: 'C', counts: { match: 5, mismatch: 1, unknown: 0, conditional: 0, hardMismatch: 1, softMismatch: 0, configurable: 0 } }, + { candidateInternalPn: 'A', counts: { match: 5, mismatch: 0, unknown: 1, conditional: 0, hardMismatch: 0, softMismatch: 0, configurable: 0 } }, + { candidateInternalPn: 'B', counts: { match: 6, mismatch: 0, unknown: 0, conditional: 1, hardMismatch: 0, softMismatch: 0, configurable: 1 } }, + { candidateInternalPn: 'D', counts: { match: 7, mismatch: 0, unknown: 0, conditional: 0, hardMismatch: 0, softMismatch: 0, configurable: 0 } }, + ], + }); + const results = out['results'] as Array<{ candidateInternalPn: string; recommendationLevel: string; riskLevel: string }>; + expect(results.map((r) => [r.candidateInternalPn, r.recommendationLevel, r.riskLevel])).toEqual([ + ['C', 'not_recommended', 'high'], + ['A', 'conditional', 'medium'], + ['B', 'alternate', 'medium'], + ['D', 'recommended', 'low'], + ]); + }); + + it('既有 UNKNOWN 又有 configurable:UNKNOWN 优先 → 条件推荐(验证闭环前不给备选)', async () => { + const out = await call('part-substitution-assessment.recommend', { + candidates: [{ candidateInternalPn: 'E', counts: { match: 1, mismatch: 0, unknown: 1, conditional: 1, hardMismatch: 0, softMismatch: 0, configurable: 1 } }], + }); + expect((out['results'] as Array<{ recommendationLevel: string }>)[0]?.recommendationLevel).toBe('conditional'); + }); +}); diff --git a/apps/api/src/app/__tests__/seed-mvp-data.test.ts b/apps/api/src/app/__tests__/seed-mvp-data.test.ts index c854677..45a85a2 100644 --- a/apps/api/src/app/__tests__/seed-mvp-data.test.ts +++ b/apps/api/src/app/__tests__/seed-mvp-data.test.ts @@ -6,19 +6,52 @@ * 2026-07-31 重分:单据归各活动自己的域,这个文件只留**主数据**,按常规 CRM / ERP 分四域。 * * 守的是三条,每条都能机检: - * · 只有这四个域,不多不少 —— 多一个就说明有人把单据塞进主数据了; + * · 八个域,多一个就说明有人把单据塞进主数据了; * · 每张表都是 `master` 且**不带单标识** —— 带了就是单据归错类(安装静态审也会拦); * · 主键是**业务实体**,不是单。 */ import { describe, expect, it } from 'vitest'; -import { MASTER_DOMAINS, MASTER_OBJECTS } from '../seed-mvp-data.ts'; +import { MASTER_DOMAINS, MASTER_OBJECTS, MASTER_SAMPLE_ROWS } from '../seed-mvp-data.ts'; describe('主数据四域', () => { - it('只有客户 / 项目 / 供应商 / 市场四个域', () => { - expect([...MASTER_DOMAINS]).toEqual(['customer', 'project', 'supplier', 'market']); + it('八个域:客户 / 项目 / 供应商 / 市场 + 料件 / 需求 / 替代 / 验证(SS02 差异评估 2026-08-26 加后四域)', () => { + expect([...MASTER_DOMAINS]).toEqual(['customer', 'project', 'supplier', 'market', 'parts', 'demand', 'substitution', 'validation']); expect([...new Set(MASTER_OBJECTS.map((o) => o.domain))].sort()).toEqual([...MASTER_DOMAINS].sort()); }); + it('SS02 差异评估要读写的七张主数据表都在基线里,主键照《统一方案》', () => { + const pk = (domain: string, object: string) => + MASTER_OBJECTS.find((o) => o.domain === domain && o.object === object)?.fields.filter((f) => f.primaryKey).map((f) => f.name); + expect(pk('parts', 'profile')).toEqual(['internal_pn']); + expect(pk('parts', 'parameter')).toEqual(['internal_pn', 'param_name']); + expect(pk('parts', 'document')).toEqual(['internal_pn', 'doc_seq']); + expect(pk('demand', 'request')).toEqual(['request_id']); + expect(pk('substitution', 'relation')).toEqual(['substitution_relation_id']); + expect(pk('substitution', 'difference_item')).toEqual(['substitution_relation_id', 'difference_item_id']); + expect(pk('validation', 'record')).toEqual(['validation_id']); + }); + + it('样例料号:原 PN 与同族可调版在库,候选 XL2596S-5.0 刻意不播(数据工单那条路要试得出来)', () => { + const parts = MASTER_SAMPLE_ROWS.filter((r) => r.address.domain === 'parts' && r.address.object === 'profile').map((r) => r.key['internal_pn']); + expect(parts).toEqual(['LM2596S-5.0', 'LM2596S-ADJ']); + expect(parts).not.toContain('XL2596S-5.0'); + }); + + it('样例料号的标准化参数集是独立子表 parts.parameter:两颗料各 7 行,主键是 (internal_pn, param_name)', () => { + const params = MASTER_SAMPLE_ROWS.filter((r) => r.address.domain === 'parts' && r.address.object === 'parameter'); + const byPn = (pn: string) => params.filter((r) => r.key['internal_pn'] === pn); + expect(byPn('LM2596S-5.0')).toHaveLength(7); + expect(byPn('LM2596S-ADJ')).toHaveLength(7); + for (const row of params) { + expect(Object.keys(row.key).sort()).toEqual(['internal_pn', 'param_name']); + expect(row.values['param_value'], JSON.stringify(row.key)).toBeTruthy(); + expect(row.values['constraint_type']).toMatch(/^(hard|soft)$/); + } + // parts.profile 不再声明这一列的值 —— 两行样例主记录里它应为空(物理列留在基线,不再写) + const profiles = MASTER_SAMPLE_ROWS.filter((r) => r.address.domain === 'parts' && r.address.object === 'profile'); + for (const row of profiles) expect(row.values['normalized_parameter_set']).toBeUndefined(); + }); + it('四个域各自都有表 —— 空占位也得立得住', () => { for (const d of MASTER_DOMAINS) { expect(MASTER_OBJECTS.filter((o) => o.domain === d).length, `${d} 域一张表都没有`).toBeGreaterThan(0); diff --git a/apps/api/src/app/__tests__/view-table-edit.test.ts b/apps/api/src/app/__tests__/view-table-edit.test.ts index d7c4089..e3d2f0b 100644 --- a/apps/api/src/app/__tests__/view-table-edit.test.ts +++ b/apps/api/src/app/__tests__/view-table-edit.test.ts @@ -19,7 +19,7 @@ * 抄一份的下场踩过 —— 生产改了、测没跟着改,测全绿而线上照旧。 */ import { describe, expect, it } from 'vitest'; -import { findKnownRow, gateAddressesOf, gateOf, parseRowKey, resolveRowKey, rowChanged, writesOf } from '../routes/desk.ts'; +import { emptyGate, findKnownRow, gateAddressesOf, gateOf, parseRowKey, resolveRowKey, rowChanged, writesOf } from '../routes/desk.ts'; import { missingReadings } from '../wiring/engines.ts'; /** A1 受理记录的声明(裁到这一段用得着的几列):PN 与年用量必填 */ @@ -284,6 +284,36 @@ describe('闸看哪几张表:卡上绑的优先,没绑回落到必交付物声 ).toEqual(['quote_intake.record', 'quote_intake.verdict']); }); + it('**卡自己声明了 gateLedgers → 看它,不回落到交付物**(2026-08-27 W05 实测:数据工单要补的是 parts.* 主数据,不在必交付物名单里,闸盯着一堆无关的表、一格不缺,空手交卷一路放行)', () => { + expect( + gateAddressesOf(undefined, [{ ledgers: ['sub_eval.input_gap', 'substitution.relation'] }], ['parts.profile', 'parts.parameter']), + ).toEqual(['parts.profile', 'parts.parameter']); + }); + + it('**卡自报的表一行都没有 = 没完成**(2026-08-27 W05 e2e:模型压拍没写骨架就发了数据工单,件上空空如也,而「缺必填」只数已有行 → 零行零缺、闸照开)', () => { + const watched = [ + { domain: 'parts', object: 'profile', label: '芯片主数据' }, + { domain: 'parts', object: 'parameter', label: '标准化参数集' }, + ]; + const declared = ['parts.profile', 'parts.parameter']; + expect(emptyGate({}, watched, declared)?.ready).toBe(false); + expect(emptyGate({}, watched, declared)?.why).toContain('芯片主数据、标准化参数集'); + // 两张都有行 → 不归这一段管,交给「缺不缺必填」那一段 + expect(emptyGate({ 'mine:parts.profile': [{}], 'mine:parts.parameter': [{}] }, watched, declared)).toBeUndefined(); + // 一张有一张没有 → 只点没有的那一张 + expect(emptyGate({ 'mine:parts.profile': [{}] }, watched, declared)?.why).toContain('标准化参数集'); + }); + + it('卡没自报(回落到必交付物那条老路)→ 零行不拦人:那条路上零行是常态', () => { + expect(emptyGate({}, [{ domain: 'a', object: 'b' }], [])).toBeUndefined(); + }); + + it('优先级:绑的表 > 卡自报 > 交付物;空串与空白不算数', () => { + expect(gateAddressesOf([table('quote_intake.record')], [{ ledgers: ['a.b'] }], ['parts.profile'])).toEqual(['quote_intake.record']); + expect(gateAddressesOf(undefined, [{ ledgers: ['a.b'] }], ['', ' '])).toEqual(['a.b']); + expect(gateAddressesOf(undefined, [{ ledgers: ['a.b'] }], [' parts.profile '])).toEqual(['parts.profile']); + }); + it('老清单只给 ledger 单张 → 退它那一张;两边都空才真的没有依据', () => { expect(gateAddressesOf([], [{ ledger: 'quote_sourcing.quote_list' }])).toEqual(['quote_sourcing.quote_list']); expect(gateAddressesOf([], [{}])).toEqual([]); diff --git a/apps/api/src/app/routes/desk.ts b/apps/api/src/app/routes/desk.ts index 047b264..cdd536e 100644 --- a/apps/api/src/app/routes/desk.ts +++ b/apps/api/src/app/routes/desk.ts @@ -794,33 +794,74 @@ async function submitGate( if (task === undefined) return undefined; const manifest = await container.registry.manifestOf(task.activityId).catch(() => undefined); if (manifest === undefined) return undefined; - const addresses = gateAddressesOf(order.blocks, manifest.contract.requiredDeliverables); + const addresses = gateAddressesOf(order.blocks, manifest.contract.requiredDeliverables, order.gateLedgers); if (addresses.length === 0) return undefined; const watched = manifest.declarations.ledger.filter((l) => addresses.includes(`${l.domain}.${l.object}`)); if (watched.length === 0) return undefined; + /* + * **卡自己点名要拦的表,「一行都没有」也算没完成**(2026-08-27 W05 e2e 实测)。 + * + * 缺必填的算法只数**已有行**缺不缺格子 —— 零行 = 零缺,闸照开。实测那一单: + * 模型压拍,骨架一行没写就把 P-08 数据工单发了出去;人打开件是空的,提交钮却绿着, + * 交上去「主数据已创建」而库里一颗料都没有,一路走到 S2 才被 refersTo 那道墙拦下。 + * 只对**卡自报**(`gateLedgers`)那几张表这么判 —— 那是发卡的人明说「这张卡就是来填它的」; + * 回落到必交付物的老路一个字不变(那条路上零行是常态,比如还没到写的时候)。 + */ + const declared = (order.gateLedgers ?? []).map((a) => a.trim()).filter((a) => a !== ''); // 本单写下的行 —— 与任务视图同一约定(`mine:域.对象`) const mine: Record = {}; for (const draft of await container.ledger.taskDrafts(taskId)) { (mine[`mine:${draft.domain}.${draft.object}`] ??= []).push({ ...draft.key, ...draft.patch }); } - return gateOf(missingReadings(mine, watched), watched); + return emptyGate(mine, watched, declared) ?? gateOf(missingReadings(mine, watched), watched); } /** - * 闸看哪几张表:卡上绑了表就看绑的那几张;没绑(执行卡零输入之后是常态) - * 回落到**必交付物的台账声明**(`ledgers` 全表,老清单退 `ledger` 单张)。 - * 两边都空才真的没有依据。抽成纯函数是为了钉测 —— 回落断了闸就整个失效, - * 而失效的闸在页面上看不出来(按钮照常绿着)。 + * **卡自报要拦的表里,有没有「一行都没有」的** —— 有就是没完成,别的都不用算了。 + * + * 「缺必填」的算法只数**已有行**缺不缺格子:零行 = 零缺,闸照开(2026-08-27 W05 e2e 实测)。 + * 那一单模型压拍、骨架一行没写就把数据工单发了出去 —— 人打开件是空的、什么也补不了, + * 提交钮却绿着;交上去「主数据已创建」而库里一颗料都没有,一路走到 S2 才被引用检查拦下。 + * + * 只对**卡自报**(`gateLedgers`)那几张表这么判:那是发卡的人明说「这张卡就是来填它的」。 + * 回落到必交付物的老路一个字不变 —— 那条路上零行是常态(还没轮到写的时候)。 + */ +export function emptyGate( + mine: Readonly>>, + watched: ReadonlyArray<{ domain: string; object: string; label?: string | undefined }>, + declared: ReadonlyArray, +): { ready: boolean; why: string; blanks: string[] } | undefined { + if (declared.length === 0) return undefined; + const empty = watched.filter( + (l) => declared.includes(`${l.domain}.${l.object}`) && (mine[`mine:${l.domain}.${l.object}`] ?? []).length === 0, + ); + if (empty.length === 0) return undefined; + const names = empty.map((l) => l.label ?? `${l.domain}.${l.object}`); + return { ready: false, why: `${names.join('、')} 这一单还一行都没有 —— 这张卡就是来建它的,先在件上加一行填好再提交`, blanks: [] }; +} + +/** + * 闸看哪几张表,三级取一: + * ①卡上绑了表(`blocks`)就看绑的那几张; + * ②**卡自己声明了 `gateLedgers`** 就看它 —— 零输入卡里,只有发卡的人知道这一张卡要人补哪几张表 + * (2026-08-27 W05 实测:数据工单要补的是 `parts.*` 主数据,不在必交付物名单里, + * 闸于是盯着一堆与这张卡无关的表、一格不缺、空手交卷照放); + * ③都没有才回落到**必交付物的台账声明**(`ledgers` 全表,老清单退 `ledger` 单张)。 + * 三级全空才真的没有依据 —— **没有依据的时候不拦人**。 + * 抽成纯函数是为了钉测:回落断了闸就整个失效,而失效的闸在页面上看不出来(按钮照常绿着)。 */ export function gateAddressesOf( blocks: ReadonlyArray | undefined, deliverables: ReadonlyArray<{ ledger?: string | undefined; ledgers?: ReadonlyArray | undefined }>, + declared?: ReadonlyArray | undefined, ): string[] { const bound = (blocks ?? []) .filter((b): b is Extract => b.t === 'table' && typeof b.ledger === 'string') .map((b) => b.ledger as string); if (bound.length > 0) return bound; + const own = (declared ?? []).map((a) => a.trim()).filter((a) => a !== ''); + if (own.length > 0) return own; return deliverables.flatMap((d) => [...(d.ledgers ?? (d.ledger === undefined ? [] : [d.ledger]))]); } diff --git a/apps/api/src/app/seed-activities.ts b/apps/api/src/app/seed-activities.ts index 5d6a417..c94bd7c 100644 --- a/apps/api/src/app/seed-activities.ts +++ b/apps/api/src/app/seed-activities.ts @@ -15,7 +15,8 @@ import { readFile } from 'node:fs/promises'; import { join, resolve } from 'node:path'; import { activityManifestSchema } from '@contracts'; import type { Container } from './container.ts'; -import { MASTER_OBJECTS, MASTER_SAMPLE_ROWS } from './seed-mvp-data.ts'; +import { MASTER_DOMAINS, MASTER_OBJECTS, MASTER_SAMPLE_ROWS } from './seed-mvp-data.ts'; +import { W05_TOOLS, W05_TOOL_SAMPLE } from './tools-w05.ts'; /** 已开发完成、要随播种装上的真活动包(目录名 = 包目录,不是 activityId) */ /* @@ -29,8 +30,9 @@ import { MASTER_OBJECTS, MASTER_SAMPLE_ROWS } from './seed-mvp-data.ts'; * 再跑 activities:install 即可 —— 它们的 dist 照旧随 activities:build 产出。 * 退役名单:quote-intake · quote-alternative · quote-sourcing · quote-pricing · * quote-negotiate · quote-archive + * 2026-08-26 加 ACT-WORK-05(part-substitution-assessment):差异评估活动开发完成,随本轮登记进安装通道。 */ -const REAL_PACKAGES = ['crm-relationship-coverage', 'brand-content-toolkit'] as const; +const REAL_PACKAGES = ['crm-relationship-coverage', 'brand-content-toolkit', 'part-substitution-assessment'] as const; /** * 活动包根目录。 @@ -61,10 +63,21 @@ export async function installRealActivities(container: Container): Promise const applied = await container.ledger.applyDeclarations(MASTER_OBJECTS); const conflicts = applied.flatMap((r) => r.conflicts); log( - ` 主数据四域已物化:${MASTER_OBJECTS.length} 张表` + + ` 主数据 ${MASTER_DOMAINS.length} 域已物化:${MASTER_OBJECTS.length} 张表` + // 冲突要如实报:静默吞掉的话,表结构和声明对不上而没人知道 (conflicts.length === 0 ? '' : ` —— 合并冲突 ${conflicts.length} 处:${conflicts.map((c) => c.field).join('、')}`), ); + + /* + * **纯工具随活动一起注册**(2026-08-26):从前工具契约只在 db:seed 里注册,只跑 activities:install 的 + * 开发机上,活动清单声明了工具、白名单也发了,`sys.tool` 里却没有那件工具 —— 第一次跑就撞「工具不存在」。 + * 「安装即用」包含它声明过的纯工具能调得动。register 按 name+version 幂等,重复装是 no-op。 + */ + for (const contract of W05_TOOLS) { + const verdict = await container.toolbox.register({ contract, samples: [W05_TOOL_SAMPLE] }); + if (!verdict.accepted) log(` 工具 ${contract.name} 未过两审:${verdict.staticFindings.map((f) => f.message).join('; ')}`); + } + const root = activitiesRoot(); for (const dir of REAL_PACKAGES) { @@ -140,5 +153,5 @@ export async function installRealActivities(container: Container): Promise cause: { kind: 'governance', ref: 'seed:master-sample' }, }); } - log(` 样例客户已就位:${MASTER_SAMPLE_ROWS[1]?.values.email ?? ''}(样例 2 用它试老客户那条路)`); + log(` 样例主数据已就位:${MASTER_SAMPLE_ROWS.length} 行(客户 / 项目 / 联系人 / 料号)`); } diff --git a/apps/api/src/app/seed-mvp-data.ts b/apps/api/src/app/seed-mvp-data.ts index 249fe89..0a544d8 100644 --- a/apps/api/src/app/seed-mvp-data.ts +++ b/apps/api/src/app/seed-mvp-data.ts @@ -19,7 +19,7 @@ * 表建出来但一行数据都没有 —— 治理台「主数据」那一区能看见它们等着被接上。 */ import { objectDeclarationSchema } from '@contracts'; -import type { LedgerFieldType, ObjectDeclaration } from '@contracts'; +import type { LedgerAddress, LedgerFieldType, LedgerKey, LedgerRow, ObjectDeclaration } from '@contracts'; const f = (name: string, type: LedgerFieldType, label: string, primaryKey = false) => ({ name, @@ -142,10 +142,141 @@ export const MASTER_OBJECTS: readonly ObjectDeclaration[] = [ f('stock', 'integer', '可见库存'), f('trend', 'text', '走势'), ]), + + /* ── 料件:P-08 芯片主数据 / P-10 原厂技术资料库(SS02 差异评估 2026-08-26 加,2026-08-27 结构改)── + 字段名与《SS02-SS03-SS04_Demo台账字段细化与统一方案》§4.2 一字不差;全链路只认 internal_pn。 + 标准化参数集**改为独立子表 `parts.parameter`**(2026-08-27 用户当场核对实跑页面后指出: + 「做出来的页面结构必须与目标件一致」——目标件《ACT-WORK-05-数据工单-01》本就是两张表, + 表 1 一个料一行(主记录)、表 2 一个参数一行(子表,按所属料号归属);塞进主记录的一个文本 + 列违反《统一方案》§六「重复明细用子表承载,不在单一文本字段堆叠」,§4.2 里 + `normalized_parameter_set` 的数据类型本就写的是 `Structure`。物理列 `parts.profile. + normalized_parameter_set` 仍留在基线里(不删列),只是活动清单不再声明它、不再写它。 + 老的 market.part(主键 pn)不复用,记 debt 待并。 */ + master('parts', 'profile', '芯片主数据(P-08)', [ + f('internal_pn', 'text', '内部料号', true), + f('customer_pn', 'text', '客户料号'), + f('brand_name', 'text', '品牌名称'), + f('manufacturer_name', 'text', '制造商名称'), + f('specification_description', 'text', '规格描述'), + f('normalized_parameter_set', 'text', '标准化参数集(已改子表 parts.parameter,这一列不再声明/不再写)'), + f('package', 'text', '封装'), + f('process_technology', 'text', '工艺'), + f('lifecycle_status', 'text', '生命周期状态'), + f('eol_pcn_status', 'text', 'EOL/PCN 状态'), + f('datasheet_ref', 'text', 'Datasheet 引用'), + f('datasheet_version', 'text', 'Datasheet 版本'), + f('application_scenarios', 'text', '适配应用场景'), + f('pin_to_pin_relation_ref', 'text', 'Pin-to-Pin 关系引用'), + ]), + /* P-08 子表:标准化参数集,一行一参数,按 internal_pn 归属主记录(《统一方案》§六:重复明细用子表) */ + master('parts', 'parameter', '标准化参数集(P-08 子表)', [ + f('internal_pn', 'text', '所属料号', true), + f('param_name', 'text', '参数名', true), + f('param_value', 'text', '值'), + f('param_unit', 'text', '单位'), + f('constraint_type', 'text', '约束类型'), + f('param_note', 'text', '说明'), + ]), + master('parts', 'document', '原厂技术资料库(P-10)', [ + f('internal_pn', 'text', '关联内部料号', true), + f('doc_seq', 'text', '资料序号(同一料号下 01/02…)', true), + f('document_type', 'text', '资料类型'), + f('brand_name', 'text', '品牌名称'), + f('document_title', 'text', '资料标题'), + f('document_version', 'text', '资料版本'), + f('document_date', 'date', '资料发布日期'), + f('document_ref', 'text', '资料文件链接'), + f('citation_locator', 'text', '证据定位(页码/章节/表格)'), + f('source_contact_ref', 'text', '原厂支持联系人'), + f('document_status', 'text', '资料状态'), + ]), + + /* ── 需求:P-01 客户具体需求与项目任务主台账 ── */ + master('demand', 'request', '客户需求主记录(P-01)', [ + f('request_id', 'text', '需求编号', true), + f('customer_code', 'text', '客户编码'), + f('project_code', 'text', '项目编码'), + f('requirement_version', 'text', '需求版本'), + f('request_type', 'text', '需求类型'), + f('request_description', 'text', '需求描述'), + f('input_snapshot_ref', 'text', '输入快照'), + f('bom_id', 'text', 'BOM ID'), + f('bom_position', 'text', 'BOM 位'), + f('original_internal_pn', 'text', '原内部料号'), + f('customer_pn', 'text', '客户料号'), + f('application_scenario', 'text', '应用场景'), + f('technical_constraints', 'text', '技术约束'), + f('risk_level', 'text', '风险等级'), + f('verification_requirement', 'text', '验证/复测/确认要求'), + f('request_status', 'text', '需求状态'), + f('current_activity', 'text', '当前 Activity'), + f('current_stage', 'text', '当前阶段'), + f('next_action', 'text', '下一步动作'), + f('output_ref', 'text', '标准输出链接'), + ]), + + /* ── 替代:P-11 替代选型与批准关系库 —— 主记录 + 差异明细子表(《统一方案》§六:重复明细用子表)── */ + master('substitution', 'relation', '替代关系主记录(P-11)', [ + f('substitution_relation_id', 'text', '替代关系ID', true), + f('request_id', 'text', '关联需求编号'), + f('project_code', 'text', '关联项目编码'), + f('bom_position', 'text', '关联 BOM 位'), + f('original_internal_pn', 'text', '原内部料号'), + f('candidate_internal_pn', 'text', '候选内部料号'), + f('substitution_type', 'text', '替代类型'), + f('recommendation_level', 'text', '推荐等级'), + f('recommendation_reason', 'text', '推荐理由'), + f('difference_summary', 'text', '差异摘要'), + f('risk_level', 'text', '替代风险等级'), + f('verification_requirement', 'text', '验证要求'), + f('validation_id', 'text', '关联验证ID'), + f('analysis_status', 'text', '分析状态'), + /* 客户批准三列由独立审批流维护 —— 基线建列,差异评估活动**不声明写权** */ + f('customer_approval_status', 'text', '客户批准状态'), + f('customer_approval_at', 'timestamp', '客户批准时间'), + f('customer_approval_ref', 'text', '客户批准凭证'), + f('customer_feedback', 'text', '客户反馈'), + f('analysis_report_ref', 'text', '替代分析报告'), + f('confidence_score', 'number', '证据可信度'), + f('rule_version', 'text', '差异规则版本'), + ]), + master('substitution', 'difference_item', '差异明细(P-11 子表)', [ + f('substitution_relation_id', 'text', '替代关系ID', true), + f('difference_item_id', 'text', '差异明细ID', true), + f('parameter_name', 'text', '标准参数名'), + f('original_value', 'text', '原物料参数值'), + f('candidate_value', 'text', '候选物料参数值'), + f('parameter_unit', 'text', '参数单位'), + f('constraint_type', 'text', '约束类型'), + f('difference_status', 'text', '差异状态'), + f('impact_statement', 'text', '影响说明'), + f('risk_level', 'text', '风险等级'), + f('evidence_ref', 'text', '差异证据引用'), + f('confidence', 'number', 'AI 置信度'), + f('rule_version', 'text', '差异规则版本'), + ]), + + /* ── 验证:P-06 样品交付与芯片验证记录(事实类:只能实测产生,数据工单不许建)── */ + master('validation', 'record', '芯片验证记录(P-06)', [ + f('validation_id', 'text', '验证ID', true), + f('request_id', 'text', '关联需求编号'), + f('customer_code', 'text', '客户编码'), + f('validation_internal_pn', 'text', '验证内部料号'), + f('validation_type', 'text', '验证类型'), + f('test_condition', 'text', '测试条件'), + f('test_parameters', 'text', '测试参数'), + f('test_result', 'text', '测试结果'), + f('validation_status', 'text', '验证状态'), + f('issue_risk', 'text', '问题与风险'), + f('sample_version', 'text', '样品版本'), + f('sample_lot', 'text', '样品批次'), + f('evidence_ref', 'text', '验证证据引用'), + f('next_validation_action', 'text', '后续验证动作'), + ]), ]; -/** 四域的呈现次序 —— 谁在买 → 为什么买 → 从哪买 → 买什么 */ -export const MASTER_DOMAINS = ['customer', 'project', 'supplier', 'market'] as const; +/** 八域的呈现次序 —— 谁在买 → 为什么买 → 从哪买 → 买什么 → 料件 → 需求 → 替代 → 验证 */ +export const MASTER_DOMAINS = ['customer', 'project', 'supplier', 'market', 'parts', 'demand', 'substitution', 'validation'] as const; /** * **样例客户** —— 让「老客户」那条路试得出来。 @@ -158,7 +289,7 @@ export const MASTER_DOMAINS = ['customer', 'project', 'supplier', 'market'] as c * 只播这一位,且是**幂等的按主键写**:它是让样例跑得起来的最小夹具, * 不是往主数据里塞演示数据 —— 真实客户由 A1 建档时一位一位落进来。 */ -export const MASTER_SAMPLE_ROWS = [ +export const MASTER_SAMPLE_ROWS: readonly { address: LedgerAddress; key: LedgerKey; values: LedgerRow }[] = [ /* * **Itelma** —— 老客户测试案例的那一位(照 `JCAI_PRD/docs/活动执行页/` 两份目标件)。 * 俄罗斯车规电子、项目制;客户码 CU-0142 就是需求件上写的「已命中客户资料库」那一条。 @@ -344,4 +475,88 @@ export const MASTER_SAMPLE_ROWS = [ review_note: '', }, }, + /* + * ── SS02 差异评估的样例料号(2026-08-26,2026-08-27 参数集改子表)── + * 只播**原 PN**与**同族可调版**两颗:「都在库」那条路靠它们;候选 XL2596S-5.0 与国产 DCDC + * **刻意不播** —— 「候选缺库 → 派数据工单」「硬约束不推荐」两条路要试得出来,库里得真没有。 + * 标准化参数集是独立子表 `parts.parameter`,一颗料 7 行(与目标件《数据工单-01》的 + * 表 2 示例预填同形);数值照旧版 `normalized_parameter_set` 文本行逐条搬,一个字不改。 + */ + { + address: { domain: 'parts', object: 'profile' }, + key: { internal_pn: 'LM2596S-5.0' }, + values: { + internal_pn: 'LM2596S-5.0', + brand_name: 'TI', + manufacturer_name: 'Texas Instruments', + specification_description: '降压型 DCDC 稳压器,3A,固定 5.0V,150kHz', + package: 'TO-263-5', + process_technology: 'BCD', + lifecycle_status: 'nrnd', + eol_pcn_status: 'PCN-2026-07:转 NRND,2027-01 起不接新设计', + datasheet_ref: 'https://www.ti.com/lit/ds/symlink/lm2596.pdf', + datasheet_version: 'Rev H (2023-09)', + application_scenarios: '工业电源;消费电源', + }, + }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '输入电压范围' }, values: { internal_pn: 'LM2596S-5.0', param_name: '输入电压范围', param_value: '4.5~40', param_unit: 'V', constraint_type: 'hard', param_note: '客户输入上限 40V' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '输出电压' }, values: { internal_pn: 'LM2596S-5.0', param_name: '输出电压', param_value: '5.0', param_unit: 'V', constraint_type: 'hard', param_note: '固定版' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '输出电流' }, values: { internal_pn: 'LM2596S-5.0', param_name: '输出电流', param_value: '3', param_unit: 'A', constraint_type: 'hard', param_note: '满载能力' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '开关频率' }, values: { internal_pn: 'LM2596S-5.0', param_name: '开关频率', param_value: '150', param_unit: 'kHz', constraint_type: 'hard', param_note: '影响外围电感/电容' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '静态电流' }, values: { internal_pn: 'LM2596S-5.0', param_name: '静态电流', param_value: '5', param_unit: 'mA', constraint_type: 'soft', param_note: '待机功耗' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '工作温度' }, values: { internal_pn: 'LM2596S-5.0', param_name: '工作温度', param_value: '-40~+85', param_unit: '℃', constraint_type: 'hard', param_note: '工业温域' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-5.0', param_name: '使能阈值' }, values: { internal_pn: 'LM2596S-5.0', param_name: '使能阈值', param_value: '1.4', param_unit: 'V', constraint_type: 'hard', param_note: 'ON/OFF 引脚阈值' } }, + { + address: { domain: 'parts', object: 'profile' }, + key: { internal_pn: 'LM2596S-ADJ' }, + values: { + internal_pn: 'LM2596S-ADJ', + brand_name: 'TI', + manufacturer_name: 'Texas Instruments', + specification_description: '降压型 DCDC 稳压器,3A,可调输出 1.23~37V,150kHz(LM2596 同族)', + package: 'TO-263-5', + process_technology: 'BCD', + lifecycle_status: 'active', + datasheet_ref: 'https://www.ti.com/lit/ds/symlink/lm2596.pdf', + datasheet_version: 'Rev H (2023-09)', + application_scenarios: '工业电源;消费电源', + }, + }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '输入电压范围' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '输入电压范围', param_value: '4.5~40', param_unit: 'V', constraint_type: 'hard', param_note: '与固定版同' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '输出电压' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '输出电压', param_value: '1.23~37', param_unit: 'V', constraint_type: 'hard', param_note: '可调版,靠外围反馈网络定' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '输出电流' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '输出电流', param_value: '3', param_unit: 'A', constraint_type: 'hard', param_note: '满载能力' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '开关频率' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '开关频率', param_value: '150', param_unit: 'kHz', constraint_type: 'hard', param_note: '影响外围电感/电容' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '静态电流' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '静态电流', param_value: '5', param_unit: 'mA', constraint_type: 'soft', param_note: '待机功耗' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '工作温度' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '工作温度', param_value: '-40~+85', param_unit: '℃', constraint_type: 'hard', param_note: '工业温域' } }, + { address: { domain: 'parts', object: 'parameter' }, key: { internal_pn: 'LM2596S-ADJ', param_name: '使能阈值' }, values: { internal_pn: 'LM2596S-ADJ', param_name: '使能阈值', param_value: '1.4', param_unit: 'V', constraint_type: 'hard', param_note: 'ON/OFF 引脚阈值' } }, + { + address: { domain: 'parts', object: 'document' }, + key: { internal_pn: 'LM2596S-5.0', doc_seq: '01' }, + values: { + internal_pn: 'LM2596S-5.0', + doc_seq: '01', + document_type: 'datasheet', + brand_name: 'TI', + document_title: 'LM2596 SIMPLE SWITCHER Power Converter 150-kHz 3-A Step-Down Voltage Regulator', + document_version: 'Rev H (2023-09)', + document_ref: 'https://www.ti.com/lit/ds/symlink/lm2596.pdf', + citation_locator: '§6.5 Electrical Characteristics 表 / §6.3 Recommended Operating Conditions', + document_status: 'valid', + }, + }, + { + address: { domain: 'parts', object: 'document' }, + key: { internal_pn: 'LM2596S-ADJ', doc_seq: '01' }, + values: { + internal_pn: 'LM2596S-ADJ', + doc_seq: '01', + document_type: 'datasheet', + brand_name: 'TI', + document_title: 'LM2596 SIMPLE SWITCHER Power Converter 150-kHz 3-A Step-Down Voltage Regulator', + document_version: 'Rev H (2023-09)', + document_ref: 'https://www.ti.com/lit/ds/symlink/lm2596.pdf', + citation_locator: '§6.5 Electrical Characteristics 表(ADJ 列)', + document_status: 'valid', + }, + }, ] as const; diff --git a/apps/api/src/app/seed-mvp.ts b/apps/api/src/app/seed-mvp.ts index cad8758..fc6d5d4 100644 --- a/apps/api/src/app/seed-mvp.ts +++ b/apps/api/src/app/seed-mvp.ts @@ -12,6 +12,7 @@ import type { Container } from './container.ts'; import { installRealActivities } from './seed-activities.ts'; import { installSlots } from './seed-mvp-slots.ts'; import { seedMvpFlow } from './seed-mvp-flow.ts'; +import { W05_TOOLS } from './tools-w05.ts'; /** 第一方功能工具:查历史价 —— MVP 用录制回放替身代真 CRM(README:mock 只在外界) */ const HISTORY_TOOL = { @@ -328,7 +329,7 @@ export async function seedMvp(container: Container): Promise { log(`① LLM 实例已绑定:deepseek-v4-flash · deepseek-v4-pro${apiKey === undefined ? '(环境无密钥 —— 两条都是未绑定,去治理台补)' : ''}`); /* ② 功能工具注册两审 + 逐槽位白名单 */ - for (const contract of [HISTORY_TOOL, MAIL_TOOL, CLASSIFY_TOOL, PLACEHOLDER_TOOL, COVERAGE_SCORE_TOOL, RANK_KEY_PERSONS_TOOL]) { + for (const contract of [HISTORY_TOOL, MAIL_TOOL, CLASSIFY_TOOL, PLACEHOLDER_TOOL, COVERAGE_SCORE_TOOL, RANK_KEY_PERSONS_TOOL, ...W05_TOOLS]) { const verdict = await container.toolbox.register({ contract, samples: [ @@ -359,7 +360,7 @@ export async function seedMvp(container: Container): Promise { for (const [activityId, tools] of Object.entries(ALLOWLIST)) { await container.toolbox.setAllowlist(activityId, tools); } - log('② 功能工具已注册并入白名单(读类 1 · 写类 1 · 纯工具 4,逐活动授权)'); + log('② 功能工具已注册并入白名单(读类 1 · 写类 1 · 纯工具 6,逐活动授权)'); /* * ③ 活动装入 —— 两批: diff --git a/apps/api/src/app/tools-w05.ts b/apps/api/src/app/tools-w05.ts new file mode 100644 index 0000000..219e0c7 --- /dev/null +++ b/apps/api/src/app/tools-w05.ts @@ -0,0 +1,87 @@ +/** + * ACT-WORK-05 差异评估的两枚纯工具契约(活动私有作用域)。 + * 两处消费:`seed-mvp.ts`(db:seed 全套播种)与 `seed-activities.ts`(activities:install 装活动时顺带注册 —— + * 「安装即用」包含它声明过的纯工具能调得动;从前 E04 的工具只在 db:seed 里注册,开发机上只跑 + * activities:install 的人第一次跑活动就撞「工具不存在」)。 + */ +const PURE = { + effect: 'read' as const, + errors: [] as Array<{ code: string; retryable: boolean; message: string }>, + idempotent: true, + timeoutMs: 5_000, + retries: 0, + connectionKeys: [] as string[], + pure: true, + ownerActivityId: 'part-substitution-assessment', +}; + +/** 逐参数比对 —— 出参键与台账列同名(difference_status / risk_level),模型照抄 */ +export const COMPARE_PARAMETERS_TOOL = { + ...PURE, + name: 'part-substitution-assessment.compare-parameters', + displayName: '替代料逐参数比对', + version: '1.0.0', + description: + '按硬/软约束逐参数比对原 PN 与候选 PN,输出四态 difference_status(match/mismatch/unknown/conditional)、' + + 'compare_result、risk_level 与各候选的计数。一次可比一批候选(candidates 数组),每对参数可带客户约束 requirement(如 ">= 40")与证据引用 evidenceRef;' + + '硬约束没有证据引用不判 match。规则版本 R-2026.07。', + input: { + type: 'object', + properties: { + candidates: { + type: 'array', + description: '[{candidateInternalPn, pairs:[{parameterName, originalValue, candidateValue, unit?, constraintType:"hard"|"soft", requirement?, evidenceRef?}]}]', + }, + }, + }, + output: { + type: 'object', + properties: { + ruleVersion: { type: 'string' }, + results: { + type: 'array', + description: '[{candidateInternalPn, items:[{parameterName, unit, constraintType, compareResult, differenceStatus, riskLevel, note}], counts:{match,mismatch,unknown,conditional,hardMismatch,softMismatch,configurable}}]', + }, + }, + }, +}; + +/** 推荐定级 —— 出参 recommendationLevel / riskLevel / reason 直接落 P-11 */ +export const RECOMMEND_TOOL = { + ...PURE, + name: 'part-substitution-assessment.recommend', + displayName: '替代推荐定级', + version: '1.0.0', + description: + '按每个候选的比对计数定推荐等级:硬约束 mismatch>0 → not_recommended;unknown>0 → conditional;' + + '只有可调配成(configurable)→ alternate;其余 conditional → conditional;全 match → recommended。', + input: { + type: 'object', + properties: { + candidates: { type: 'array', description: '[{candidateInternalPn, counts:{match,mismatch,unknown,conditional,hardMismatch,softMismatch,configurable}}]' }, + }, + }, + output: { + type: 'object', + properties: { + ruleVersion: { type: 'string' }, + results: { type: 'array', description: '[{candidateInternalPn, recommendationLevel, riskLevel, reason}]' }, + }, + }, +}; + +export const W05_TOOLS = [COMPARE_PARAMETERS_TOOL, RECOMMEND_TOOL] as const; + +/** 试运行审的样例(两件共用一份:并集覆盖各家入参) */ +export const W05_TOOL_SAMPLE = { + input: { + candidates: [ + { + candidateInternalPn: 'XL2596S-5.0', + pairs: [{ parameterName: '输出电压', originalValue: '5.0', candidateValue: '5.0', unit: 'V', constraintType: 'hard', evidenceRef: 'P-08' }], + counts: { match: 1, mismatch: 0, unknown: 0, conditional: 0, hardMismatch: 0, softMismatch: 0, configurable: 0 }, + }, + ], + }, + expectShape: { type: 'object' }, +}; diff --git a/apps/api/src/app/tools/first-party.ts b/apps/api/src/app/tools/first-party.ts index 367da49..2c8fe52 100644 --- a/apps/api/src/app/tools/first-party.ts +++ b/apps/api/src/app/tools/first-party.ts @@ -332,6 +332,165 @@ const slotPlaceholder: ToolHandler = async ({ input }) => { }; }; +/* ── ACT-WORK-05 差异评估:逐参数比对 —— 纯工具(活动私有作用域)───────────────── + * + * 「能算的不问 LLM」:同输入必同结论。规则与活动包 manifest 里的 D01/D02 两张 DMN 同一份; + * 这里是求值器,那里是随包冻结的文档。`RULE_VERSION` 随结论落账(rule_version)。 + * + * 比对语义(按硬/软约束): + * equal / covers(候选范围 ⊇ 原范围) → match,低风险; + * configurable(原是定值、候选是含它的可调范围)→ conditional(要改外围); + * narrower / differs / partial → 硬:mismatch 高风险;软:conditional 中风险; + * 任一侧未披露 → unknown 中风险; + * 硬约束 equal/covers 但没给 evidenceRef → conditional(硬约束未经证据支持不得判 MATCH); + * requirement(客户约束,如 ">= 40")候选不满足 → 一律 mismatch 高风险。 + */ +export const SUBSTITUTION_RULE_VERSION = 'R-2026.07'; + +type Parsed = { kind: 'number'; value: number } | { kind: 'range'; lo: number; hi: number } | { kind: 'text'; value: string } | { kind: 'unknown' }; +type CompareResult = 'equal' | 'covers' | 'configurable' | 'narrower' | 'partial' | 'differs' | 'unknown'; +type DifferenceStatus = 'match' | 'mismatch' | 'unknown' | 'conditional'; +type RiskLevel = 'low' | 'medium' | 'high'; +type ParamPair = { + parameterName: string; + originalValue: string; + candidateValue: string; + unit?: string; + constraintType: 'hard' | 'soft'; + /** + * 这两格**模型爱给 null**(「这一项没有客户约束」它写 `requirement: null` 而不是省掉)—— + * 工具入参是宽松描述式 schema,null 一路落到这里,`null.trim()` 当场崩, + * 整个工具调用记成「行动被拒」(2026-08-27 W05 e2e 实测,一单撞两次)。 + * 类型如实写成可空,取值一律经 `text()`:**边界上的东西按它真会来的样子接**。 + */ + requirement?: string | null; + evidenceRef?: string | null; +}; +/** 边界上的字符串:null / undefined / 非字符串一律归成空串(模型给 null 是常态,见 ParamPair 上的注) */ +function text(v: unknown): string { + return typeof v === 'string' ? v.trim() : ''; +} + +type CompareCounts = { match: number; mismatch: number; unknown: number; conditional: number; hardMismatch: number; softMismatch: number; configurable: number }; + +const UNKNOWN_WORDS = /^(未披露|未知|未给出|unknown|n\/?a|tbd|待定|-|—|–)$/i; +const NUM = '[-+]?\\d+(?:\\.\\d+)?'; +const RANGE_RE = new RegExp(`^(${NUM})\\s*(?:~|～|-|–|—|至|to)\\s*(${NUM})`, 'i'); +const NUM_RE = new RegExp(`^(${NUM})`); + +export function parseParamValue(raw: unknown): Parsed { + const s = String(raw ?? '').trim().replace(/\s+/g, ' '); + if (s === '' || UNKNOWN_WORDS.test(s)) return { kind: 'unknown' }; + const r = RANGE_RE.exec(s); + if (r !== null) { + const lo = Number(r[1]); + 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 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() }; +} + +function compareParsed(o: Parsed, c: Parsed): CompareResult { + if (o.kind === 'unknown' || c.kind === 'unknown') return 'unknown'; + if (o.kind === 'range' && c.kind === 'range') { + if (c.lo === o.lo && c.hi === o.hi) return 'equal'; + if (c.lo <= o.lo && c.hi >= o.hi) return 'covers'; + if (c.lo >= o.lo && c.hi <= o.hi) return 'narrower'; + return c.hi < o.lo || c.lo > o.hi ? 'differs' : 'partial'; + } + if (o.kind === 'number' && c.kind === 'number') return Math.abs(o.value - c.value) <= 1e-9 ? 'equal' : 'differs'; + if (o.kind === 'number' && c.kind === 'range') return c.lo <= o.value && o.value <= c.hi ? 'configurable' : 'differs'; + if (o.kind === 'range' && c.kind === 'number') return o.lo <= c.value && c.value <= o.hi ? 'narrower' : 'differs'; + if (o.kind === 'text' && c.kind === 'text') return o.value === c.value ? 'equal' : 'differs'; + return 'differs'; +} + +/** 客户约束:">= 40" / "<= 85" / "-40~85"(候选必须盖住);解析不了当没给 */ +function satisfiesRequirement(requirement: string | null | undefined, c: Parsed): boolean | undefined { + const s = text(requirement); + if (s === '' || c.kind === 'unknown' || c.kind === 'text') return undefined; + const ge = new RegExp(`^(?:>=|≥)\\s*(${NUM})$`).exec(s); + const le = new RegExp(`^(?:<=|≤)\\s*(${NUM})$`).exec(s); + const hi = c.kind === 'range' ? c.hi : c.value; + const lo = c.kind === 'range' ? c.lo : c.value; + if (ge !== null) return hi >= Number(ge[1]); + if (le !== null) return lo <= Number(le[1]); + const req = parseParamValue(s); + if (req.kind === 'range') return lo <= req.lo && hi >= req.hi; + if (req.kind === 'number') return lo <= req.value && hi >= req.value; + return undefined; +} + +/** 生命周期不是数值:候选比原料「更活」算 covers(替 NRND 料本就是为了这个),更差才是 differs */ +const LIFECYCLE_ORDER: Record = { active: 3, nrnd: 2, risk: 2, eol: 1, discontinued: 0 }; +function compareLifecycle(o: string, c: string): CompareResult | undefined { + const ro = LIFECYCLE_ORDER[text(o).toLowerCase()]; + const rc = LIFECYCLE_ORDER[text(c).toLowerCase()]; + if (ro === undefined || rc === undefined) return undefined; + return rc === ro ? 'equal' : rc > ro ? 'covers' : 'differs'; +} + +function judgePair(p: ParamPair): { compareResult: CompareResult; differenceStatus: DifferenceStatus; riskLevel: RiskLevel; note: string } { + const o = parseParamValue(p.originalValue); + const c = parseParamValue(p.candidateValue); + const hard = p.constraintType === 'hard'; + let compareResult = compareParsed(o, c); + if (/生命周期|lifecycle/i.test(p.parameterName)) compareResult = compareLifecycle(p.originalValue, p.candidateValue) ?? compareResult; + const req = satisfiesRequirement(p.requirement, c); + if (req === false) { + // 客户约束不满足:比对结果照实留(narrower/differs),结论一律 MISMATCH 高风险 + return { compareResult: compareResult === 'unknown' ? 'differs' : compareResult, differenceStatus: 'mismatch', riskLevel: 'high', note: `不满足客户约束 ${text(p.requirement)}` }; + } + if (compareResult === 'unknown') return { compareResult, differenceStatus: 'unknown', riskLevel: 'medium', note: '一侧未披露:标 UNKNOWN,挂验证任务或补来源' }; + if (compareResult === 'equal' || compareResult === 'covers') { + if (hard && text(p.evidenceRef) === '') { + return { compareResult, differenceStatus: 'conditional', riskLevel: 'medium', note: '硬约束缺证据引用:未经证据支持不判 MATCH' }; + } + return { compareResult, differenceStatus: 'match', riskLevel: 'low', note: compareResult === 'covers' ? '候选范围盖住原范围' : '一致' }; + } + if (compareResult === 'configurable') return { compareResult, differenceStatus: 'conditional', riskLevel: 'medium', note: '候选可调,须改外围把它配成原值' }; + if (compareResult === 'partial') return { compareResult, differenceStatus: 'conditional', riskLevel: hard ? 'medium' : 'low', note: '范围部分重叠,须按应用边界确认' }; + compareResult = compareResult === 'narrower' ? 'narrower' : 'differs'; + return hard + ? { compareResult, differenceStatus: 'mismatch', riskLevel: 'high', note: '硬约束不一致' } + : { 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 } }; +}; + +/** + * 推荐定级(D02,FIRST):硬 MISMATCH → 不推荐;有 UNKNOWN → 条件推荐(等验证闭环); + * 有 configurable(改外围配得成)→ 备选;其余 conditional → 条件推荐;全 MATCH → 推荐。与 manifest 里的 D02 表同一份规则。 + */ +const recommend: ToolHandler = async ({ input }) => { + const candidates = Array.isArray(input['candidates']) ? (input['candidates'] as Array<{ candidateInternalPn: string; counts: Partial }>) : []; + const results = candidates.map((cand) => { + const n = (k: keyof CompareCounts) => Number(cand.counts?.[k] ?? 0); + if (n('hardMismatch') > 0) return { candidateInternalPn: cand.candidateInternalPn, recommendationLevel: 'not_recommended', riskLevel: 'high', reason: `硬约束 MISMATCH ${n('hardMismatch')} 项:硬约束失败直接不推荐` }; + if (n('unknown') > 0) return { candidateInternalPn: cand.candidateInternalPn, recommendationLevel: 'conditional', riskLevel: 'medium', reason: `UNKNOWN ${n('unknown')} 项待验证闭环,通过后可升级推荐` }; + if (n('configurable') > 0) return { candidateInternalPn: cand.candidateInternalPn, recommendationLevel: 'alternate', riskLevel: 'medium', reason: `${n('configurable')} 项须改外围配成原值(另有 ${n('conditional') - n('configurable')} 项条件差异):客户接受改设计则启用` }; + if (n('conditional') > 0) return { candidateInternalPn: cand.candidateInternalPn, recommendationLevel: 'conditional', riskLevel: 'medium', reason: `CONDITIONAL ${n('conditional')} 项须按应用边界确认` }; + return { candidateInternalPn: cand.candidateInternalPn, recommendationLevel: 'recommended', riskLevel: 'low', reason: `${n('match')} 项全部 MATCH` }; + }); + return { ok: true, output: { ruleVersion: SUBSTITUTION_RULE_VERSION, results } }; +}; + export const FIRST_PARTY_TOOLS: ReadonlyArray = [ ['crm.history-price-read', historyPriceRead], ['quote-intake.classify', classify], @@ -343,4 +502,6 @@ export const FIRST_PARTY_TOOLS: ReadonlyArray = ['slot.placeholder', slotPlaceholder], ['crm-relationship-coverage.recompute-score', recomputeScore], ['crm-relationship-coverage.rank-key-persons', rankKeyPersons], + ['part-substitution-assessment.compare-parameters', compareParameters], + ['part-substitution-assessment.recommend', recommend], ]; diff --git a/apps/api/src/app/wiring/engines.ts b/apps/api/src/app/wiring/engines.ts index 28ece17..3f1aae7 100644 --- a/apps/api/src/app/wiring/engines.ts +++ b/apps/api/src/app/wiring/engines.ts @@ -1002,7 +1002,7 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring { throw new Error( `${field.label ?? field.name}「${value}」在${refLabel}里不存在 —— ` + `${target.label} 的这一列只许引用台账里真实存在的值,不许自造编号或占位引用。` + - '要指的那个人/那一行还不存在的话,先把它真实建出来(要经营的人不存在就发数据录入卡收人),' + + '要指的那一行还不存在的话,先把它真实建出来(该派数据工单的派数据工单、该发数据录入卡的发录入卡),' + '或者把这一笔挂到已存在的那一行名下', ); } @@ -1685,6 +1685,15 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring { ? input.card['steps'].map((x) => String(x)).filter((x) => x.trim() !== '') : []; const standard = String(input.card['standard'] ?? '').trim(); + /* + * **这张卡该拦哪几张表** —— 零输入卡没有 `blocks`,闸只能回落到必交付物, + * 而数据工单要人补的是 `parts.*` 这类主数据(不在交付物名单里):闸盯着一堆 + * 与这张卡无关的表,一格不缺,空手交卷一路放行(2026-08-27 W05 实测)。 + * 认不出形状的一律丢掉,不把脏东西端给闸。 + */ + const gateLedgers = Array.isArray(input.card['gateLedgers']) + ? input.card['gateLedgers'].map((x) => String(x).trim()).filter((x) => /^[a-z0-9_]+\.[a-z0-9_]+$/i.test(x)) + : []; const issued = await deps.humanTool.issueExecution(context, { title, basis: basis.length > 0 ? basis : [{ k: '来源', v: '案例模型当下局面' }], @@ -1693,6 +1702,7 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring { ...(steps.length === 0 ? {} : { steps }), ...(standard === '' ? {} : { standard }), ...(blocks === undefined ? {} : { blocks: blocks as ExecutionWorkOrderDraft['blocks'] }), + ...(gateLedgers.length === 0 ? {} : { gateLedgers }), }); // 打扰率的计量对象:每发一张卡就是调了一次人 —— 不计就等于没有上限 await taskStore.addConsumption(input.taskId, { humanCalls: 1 }); diff --git a/apps/api/src/modules/loop-engine/__tests__/turn-runner-acceptance.test.ts b/apps/api/src/modules/loop-engine/__tests__/turn-runner-acceptance.test.ts index 02be286..ebff5f4 100644 --- a/apps/api/src/modules/loop-engine/__tests__/turn-runner-acceptance.test.ts +++ b/apps/api/src/modules/loop-engine/__tests__/turn-runner-acceptance.test.ts @@ -6,7 +6,7 @@ */ import { describe, expect, it } from 'vitest'; import type { TaskId } from '@contracts'; -import { createTurnRunner, echoTitleOf, handsOff, resendVerdict, sameGist, stalledTurns, toolInputHash } from '../internal/usecase/turn-runner.ts'; +import { createTurnRunner, echoTitleOf, handsOff, resendVerdict, sameGist, stalledTurns, toolInputHash, unmetWhy, answeredCardFact, earlyFinishTitleOf } from '../internal/usecase/turn-runner.ts'; import type { TurnRunnerDeps } from '../internal/usecase/turn-runner.ts'; import type { PendingAcceptance } from '../port.ts'; import type { CaseModel } from '../internal/domain/cmmn-parse.ts'; @@ -992,7 +992,7 @@ describe('宣告完成', () => { * 被拦下)。声明 doneWhen 就是说「这件事完没完可以算出来」,算出来是假,finish 就该被拒—— * 不是让模型自己判断,是让基座去核。 */ - it('声明了 doneWhen 的项:算出来是假,finish 被拒——不许凭一句话绕过基座的判断', async () => { + it('声明了 doneWhen 的项:算出来是假,这一下 finish **不生效**(头一次只落观察,不记被拒)', async () => { const h = harness({ parsed: STAGE_MODEL, runtime: READY_RUNTIME2, @@ -1005,6 +1005,25 @@ describe('宣告完成', () => { expect(outcome.runtime.items.find((i) => i.id === 'FREE')?.state).toBe('Available'); }); + /* + * **早收一次不算撞墙,第二次才算**(2026-08-27 W05 e2e:五案例里三例各白吃一次被拒 —— + * 模型把「写行 · 调工具 · finish」排在同一串,工具还没轮到调 finish 先到了,下一拍它自己补上)。 + * 与「重发已答过的卡头两次无事发生」同一把尺;真在原地打转的单仍看得见(第二次起照旧拒,喂熔断计数)。 + */ + it('同一项第二次早收:照旧被拒 —— 熔断要看得见真卡死的单', async () => { + const h = harness({ + parsed: STAGE_MODEL, + runtime: READY_RUNTIME2, + action: finish('FREE'), + steps: [{ item: 'FREE', intent: '干活', guide: '做法', writes: [], reads: [], tools: [], view: 'x', doneWhen: 'some_rows > 0' }], + sfeelCondition: () => false, + trail: [{ kind: 'observation', title: earlyFinishTitleOf('FREE') }], + }); + const outcome = await h.runner.runTurn(TASK); + expect(outcome.status).toBe('running'); + expect(h.appended.some((m) => m.kind === 'result' && m.title.includes('行动被拒'))).toBe(true); + }); + it('声明了 doneWhen 的项:算出来是真,finish 正常收', async () => { const h = harness({ parsed: STAGE_MODEL, @@ -1704,6 +1723,58 @@ describe('办完的项:话要说对,按一下不报错', () => { * 每张扣一次调人预算,四次扣完整单 `exhausted`。卡族不同,病是同一个。 * 三档由 `resendVerdict` 定:照发 / 无事发生(头两次)/ 第三次起当被拒(熔断看得见)。 */ +describe('「这张卡人已经答过了」摆成每拍都在的事实行', () => { + const sent = (title: string) => ({ kind: 'card-sent', title }); + it('**决策卡:把人选的那个值摆出来**(2026-08-27 W05 e2e:五个案例四个死在这里 —— 剧本让模型自己去轨迹里翻回传,而那条痕会被挤走)', () => { + const line = answeredCardFact([sent('请审核结论'), { kind: 'card-reply', title: '请审核结论', detail: { value: 'approve' } }]); + expect(line).toContain('人已经答过了'); + expect(line).toContain('他选的是「approve」'); + expect(line).toContain('finish'); + }); + + it('执行工单没有值 → 说清「空答复 = 照原样确认」,不编一个选择出来', () => { + const line = answeredCardFact([sent('评估输入确认'), { kind: 'card-reply', title: '评估输入确认' }]); + expect(line).toContain('空答复 = 照原样确认'); + expect(line).not.toContain('他选的是'); + }); + + it('回传之后又发了**别的**卡 → 有新问题在等,这条不摆', () => { + const line = answeredCardFact([ + sent('第一问'), + { kind: 'card-reply', title: '第一问', detail: { value: 'approve' } }, + sent('另一件完全不同的事'), + ]); + expect(line).toBe(''); + }); + + it('一张卡都没答过 → 空', () => { + expect(answeredCardFact([sent('还没答的卡')])).toBe(''); + expect(answeredCardFact([])).toBe(''); + }); +}); + +describe('doneWhen 为假的拒回:差在哪要说得出口', () => { + it('**缺的是一次工具调用就直说** —— 2026-08-27 W05 e2e:五个案例里三个撞上,拒回只教它去查「行与列」,而缺的是 recommend 没调过', () => { + const why = unmetWhy('rows > 0 and tool_w05_recommend_calls > 0', { rows: 9, tool_w05_recommend_calls: 0 }); + expect(why).toContain('缺的不是行也不是列,是一次工具调用'); + expect(why).toContain('tool_w05_recommend_calls'); + expect(why).toContain('tool_w05_recommend_calls=0'); + }); + + it('工具调过了(读数 > 0)→ 不点它的名,只把判据与读数摆出来', () => { + const why = unmetWhy('rows = 10 and tool_w05_recommend_calls > 0', { rows: 9, tool_w05_recommend_calls: 2 }); + expect(why).not.toContain('缺的不是行也不是列'); + expect(why).toContain('rows=9'); + }); + + it('判据里压根没有工具那一档 → 照旧只摆判据与读数', () => { + const why = unmetWhy('a_rows = b_rows', { a_rows: 3, b_rows: 4 }); + expect(why).toContain('a_rows=3'); + expect(why).toContain('b_rows=4'); + expect(why).not.toContain('工具调用'); + }); +}); + describe('同一张卡再发一遍的三档', () => { const sent = (title: string) => ({ kind: 'card-sent', title }); const replied = (title: string) => ({ kind: 'card-reply', title }); @@ -1717,6 +1788,21 @@ describe('同一张卡再发一遍的三档', () => { expect(resendVerdict([sent('这一问')], '这一问').kind).toBe('send'); }); + it('**人选的那个值当场摆出来**(2026-08-27 W05 e2e:人点了通过,拒回只给「值在轨迹里」这个指针,模型对不准那一条,连发五次同一张卡熔断)', () => { + const win = [sent('这一问'), { kind: 'card-reply', title: '这一问', detail: { value: 'approve', note: '试跑代答' } }]; + expect(resendVerdict(win, '这一问')).toEqual({ kind: 'echo', answered: '这一问', chose: 'approve' }); + const rejected = resendVerdict([...win, echoed('这一问'), echoed('这一问')], '这一问'); + expect(rejected).toEqual({ kind: 'reject', answered: '这一问', chose: 'approve' }); + }); + + it('回传痕里没有值(空串 / 缺 detail)→ 不编,退回原来那句指针话术', () => { + expect(resendVerdict([sent('这一问'), { kind: 'card-reply', title: '这一问', detail: { value: ' ' } }], '这一问')).toEqual({ + kind: 'echo', + answered: '这一问', + }); + expect(resendVerdict([sent('这一问'), replied('这一问')], '这一问')).toEqual({ kind: 'echo', answered: '这一问' }); + }); + it('人答过了 → 头两次无事发生(卡不真发、预算不烧)', () => { const win = [sent('这一问'), replied('这一问')]; expect(resendVerdict(win, '这一问')).toEqual({ kind: 'echo', answered: '这一问' }); diff --git a/apps/api/src/modules/loop-engine/internal/domain/lifecycle.ts b/apps/api/src/modules/loop-engine/internal/domain/lifecycle.ts index fbf35a6..51759bc 100644 --- a/apps/api/src/modules/loop-engine/internal/domain/lifecycle.ts +++ b/apps/api/src/modules/loop-engine/internal/domain/lifecycle.ts @@ -396,7 +396,10 @@ export function criterionKey(raw: string): string { } /** S-FEEL 保留字 —— 摆读数时不该把它们当成台账名去查 */ -const SFEEL_WORDS = new Set(['true', 'false', 'null', 'and', 'or', 'not', 'in', 'between']); +/** S-FEEL 保留字与**内建函数名** —— 摆读数时不该把它们当成台账名去查: + * `count(candidateInternalPns)` 里的 `count` 从前被摆成「count=(没写过)」, + * 而那是个函数,不是谁忘了写的一笔账 —— 拒回里多一个假线索,模型就会去追它(2026-08-27 实测)。 */ +const SFEEL_WORDS = new Set(['true', 'false', 'null', 'and', 'or', 'not', 'in', 'between', 'count', 'sum', 'min', 'max', 'all', 'any']); /** * 收步判据里那几个名字**此刻的读数** —— 「差在哪」要连着判据一起摆出来。 diff --git a/apps/api/src/modules/loop-engine/internal/usecase/turn-runner.ts b/apps/api/src/modules/loop-engine/internal/usecase/turn-runner.ts index 889849f..e2b78e0 100644 --- a/apps/api/src/modules/loop-engine/internal/usecase/turn-runner.ts +++ b/apps/api/src/modules/loop-engine/internal/usecase/turn-runner.ts @@ -210,6 +210,30 @@ function rejectReason(title: string): string { * 削掉它们再比。**不做包含匹配**:两个不同的缺口问句常有很长的公共前缀, * 一模糊就会把「问 A 料」当成「问 B 料」拦掉,那比多问一遍更坏。 */ +/** + * **doneWhen 为假时,「差在哪」要说得出口** —— 拒回的话是模型下一拍的行动指南。 + * + * 从前这条拒回只有一句通用话术:「常见的是该写 N 行只写了 M 行,或某一行缺了必填列」—— + * 把注意力全导向**行与列**。而收步判据里那半句常常根本不是行也不是列: + * `tool_<工具>_calls > 0`(2026-08-03 立的「机检只读基座数」扩到工具那一条)。 + * 实测(2026-08-27 W05 e2e,五个案例里三个撞上):模型跳过工具、自己把推荐等级填了, + * finish 恒被拒,而拒回教它去查行与列 —— 它只能把同样的明细再写一遍。 + * **指向两扇打不开的门,比不指还糟。** + * + * 现在把判据原文与它那几个名字**此刻的读数**一起摆出来(`readingsOf`,与断点提示同一段), + * 并且:凡是 `tool_*_calls` 这一族读数为 0 的,单独点名说「缺的不是行也不是列,是一次工具调用」。 + */ +export function unmetWhy(doneWhen: string, scope: Readonly>): string { + const head = ` 干完的判据:${doneWhen}${readingsOf(doneWhen, scope)}`; + const idle = [...new Set(doneWhen.match(/tool_[A-Za-z0-9_]+_calls/g) ?? [])].filter((name) => Number(scope[name] ?? 0) === 0); + if (idle.length === 0) return head; + return ( + `${head} —— **缺的不是行也不是列,是一次工具调用**:${idle.join(' / ')} 现在是 0,` + + '说明这一步该用的工具你还没真调过(调失败不算)。先按剧本调它,拿工具算出来的结果写盘,' + + '别自己填那几个值 —— 这一步的收步判据数的就是这枚工具的调用次数。' + ); +} + export function sameQuestion(a: string, b: string): boolean { // 标点与空白一律削掉:`\p{P}` 连全角标点一起认,逐个列举漏一个就漏一次拦截 const norm = (s: string): string => s.replace(/[\p{P}\p{S}\s]/gu, '').toLowerCase(); @@ -229,6 +253,11 @@ export function sameQuestion(a: string, b: string): boolean { return short.length >= 6 && long.startsWith(short); } +/** 「还没到收步的时候」那条观察痕的标题 —— 与「已答过没再发」同族:记与数是同一句话 */ +export function earlyFinishTitleOf(itemId: string): string { + return `还没到收步的时候,这一下 finish 没生效(${itemId})`; +} + /** 「已答过、没有再发」那条观察痕的标题 —— 记与数是同一句话,不能各写各的 */ export function echoTitleOf(answered: string): string { return `这张卡人已答过,没有再发(「${answered}」)`; @@ -246,16 +275,62 @@ export function echoTitleOf(answered: string): string { * 只把「已答过」的事实摆回轨迹;第三次起 `reject` —— 那时是真卡死了,熔断要看得见它。 */ export function resendVerdict( - window: ReadonlyArray<{ readonly kind: string; readonly title: string }>, + window: ReadonlyArray<{ readonly kind: string; readonly title: string; readonly detail?: Record | undefined }>, asked: string, -): { readonly kind: 'send' } | { readonly kind: 'echo' | 'reject'; readonly answered: string } { +): { readonly kind: 'send' } | { readonly kind: 'echo' | 'reject'; readonly answered: string; readonly chose?: string } { const trimmed = asked.trim(); if (trimmed === '') return { kind: 'send' }; - const replied = new Set(window.filter((t) => t.kind === 'card-reply').map((t) => t.title)); + const replies = window.filter((t) => t.kind === 'card-reply'); + const replied = new Set(replies.map((t) => t.title)); const same = window.find((t) => t.kind === 'card-sent' && replied.has(t.title) && sameQuestion(t.title, trimmed)); if (same === undefined) return { kind: 'send' }; const echoed = window.filter((t) => t.kind === 'observation' && t.title === echoTitleOf(same.title)).length; - return { kind: echoed >= 2 ? 'reject' : 'echo', answered: same.title }; + /* + * **他选的是什么,当场摆出来**(2026-08-27 W05 e2e 实测的一单熔断): + * 人点了「通过」,拒回却只说「值在你的轨迹里(card-reply 那一条)」—— 一个**指针**。 + * 而模型恰恰对不准那一条(轨迹里躺着好几张卡的 card-reply),于是连发五次同一张卡熔断。 + * 与 E04 那一课同源:**指南让模型去找的事实,引擎手里有现成的,就直接给它**。 + * 值就在回传痕的 `detail.value` 里(决策卡的载荷,与 payloadOf 同一约定)。 + */ + const value = replies.find((t) => t.title === same.title)?.detail?.['value']; + const chose = typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined; + return { kind: echoed >= 2 ? 'reject' : 'echo', answered: same.title, ...(chose === undefined ? {} : { chose }) }; +} + +/** + * **「这张卡人已经答过了、他选的是什么」——摆成每拍都在的一句事实**(2026-08-27 W05 e2e 逼出来的)。 + * + * 剧本里那句「先在轨迹里找这一项已答过、还没处理的 card-reply」是**让模型自己去翻窗口**, + * 而那条回传会被后面的痕挤走:实测五个案例里四个死在同一处 —— 人点了「通过」, + * 模型每拍照剧本第一档「没有回音 → 发第一张决策卡」,同一张卡连发五次熔断; + * 拒回把「他选的是 approve、接下来该写哪面旗」说得再明白也没用,因为**下一拍它又从头翻一次窗口**。 + * + * 与 worldTouched 那条(2026-08-21)、E04 的「唯引擎事实行是从」(2026-08-24)同一条治法: + * **指南让模型判的事,引擎手里有现成事实的,一律改成读事实**。 + * + * 只在「最后一次卡的往来是回传」时摆(后面又发了别的卡就说明有新问题在等,不摆); + * 决策卡摆出选中的值,执行工单如实说「空答复 = 照原样确认」。 + */ +export function answeredCardFact( + window: ReadonlyArray<{ readonly kind: string; readonly title: string; readonly detail?: Record | undefined }>, +): string { + let at = -1; + for (let i = window.length - 1; i >= 0; i -= 1) { + if (window[i]?.kind === 'card-reply') { + at = i; + break; + } + } + const reply = at < 0 ? undefined : window[at]; + if (reply === undefined) return ''; + const newer = window.slice(at + 1).some((t) => t.kind === 'card-sent' && !sameQuestion(t.title, reply.title)); + if (newer) return ''; + const value = reply.detail?.['value']; + const chose = typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined; + const head = `【这张卡人已经答过了】「${reply.title.length <= 60 ? reply.title : `${reply.title.slice(0, 60)}…`}」`; + return chose === undefined + ? `${head} → 人已交回(**空答复 = 照原样确认**,不是没答)。别再发一张一样的卡 —— 照说明书里「人交回之后」那一段办,办完 finish 这一项。` + : `${head} → **他选的是「${chose}」**。别再发一张一样的卡 —— 照说明书处理这个选择(通常是把结论落进台账的那一面记账旗,再 finish 这一项)。`; } /** @@ -537,7 +612,7 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { * 那就不该被模型一句「我 finish 了」绕过去,机检只读基座数得出来的数这条铁律, * 第五次被同一类洞违反(前四次是自报的行数/去向哨兵/入场哨兵/收步判据)。 */ - doneWhenOf?: (itemId: string) => boolean | undefined, + doneWhenOf?: (itemId: string) => { ok: boolean; why: string } | undefined, /** * **这个行动身后同一串里还有没排到的行动**(2026-08-22,E04 活单熔断实测)。 * 空转写(值一行都没变)从前一律当场拒,而「被拒停在谁那儿」把整串弃权 —— @@ -1135,8 +1210,11 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { if (verdict.kind === 'reject') { throw new Error( `这个岔路口人已经选过了(「${verdict.answered}」)—— 别再发一张一样的决策卡。` + - '他选了什么就在你的轨迹里(card-reply 那一条,detail 带着选中的值):' + - '照那个选择往下办,把这一步收掉;真有**另一个**岔路口要人定,换一件事、换一个问法。', + (verdict.chose === undefined + ? '他选了什么就在你的轨迹里(card-reply 那一条,detail 带着选中的值):' + : `**他选的是「${verdict.chose}」** —— `) + + '照这个选择往下办:照说明书把结论落进台账(通常是那一面记账旗),' + + '再 finish 这一项。真有**另一个**岔路口要人定,换一件事、换一个问法。', ); } await deps.memory.append({ @@ -1145,7 +1223,10 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { title: echoTitle, detail: { internal: true, - note: '人已经在这个岔路口选过了(选中的值在 card-reply 那一条)。别再发 —— 照他的选择接着办,办完把这一步 finish 掉。', + note: + verdict.chose === undefined + ? '人已经在这个岔路口选过了(选中的值在 card-reply 那一条)。别再发 —— 照他的选择接着办,办完把这一步 finish 掉。' + : `人已经在这个岔路口选过了,他选的是「${verdict.chose}」。别再发 —— 照这个选择把结论落进台账,再 finish 这一项。`, }, }); // 什么也没做,局面原样交回 @@ -1283,13 +1364,33 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { * 是让基座去核。算不出来(表达式写坏了)或压根没声明,不拦,原样交给模型判断。 */ const doneWhenNow = doneWhenOf?.(action.itemId); - if (doneWhenNow === false) { - throw new Error( + if (doneWhenNow?.ok === false) { + const say = `${action.itemId} 声明了 doneWhen(完没完可以算出来),但现在算出来是假 —— ` + - '不能凭这一下 finish 说它已经办完了。回头看这一步该写的东西是不是漏了一部分' + - '(常见的是:该写 N 行只写了 M 行,或某一行缺了必填列),补齐了 doneWhen 自然为真,' + - '基座会自己收,不必你再 finish。', - ); + '不能凭这一下 finish 说它已经办完了。补齐了 doneWhen 自然为真,基座会自己收,不必你再 finish。' + + doneWhenNow.why; + /* + * **早收一次不算撞墙**(2026-08-27 W05 e2e:五案例里三例各白吃一次)—— + * 与「重发已答过的卡头两次无事发生」同一把尺(设计律:按钮按两下不该变成墙)。 + * 实测那一形是**计划次序**的小错:模型把 [写行 · 调工具 · finish] 排在同一串, + * 工具还没轮到调,finish 先到了;它下一拍自己就补上了 —— + * 这种拍不该记成「行动被拒」去喂熔断计数(那是给真卡死留的)。 + * 头一次只落观察(把判据与差在哪原样摆回轨迹,和拒回一个字不差), + * 第二次起照旧拒 —— 真在原地打转的单仍然看得见。 + */ + const seen = (await deps.memory.window(taskId, STALL_WINDOW)).filter( + (t) => t.kind === 'observation' && t.title === earlyFinishTitleOf(action.itemId), + ).length; + if (seen === 0) { + await deps.memory.append({ + taskId, + kind: 'observation', + title: earlyFinishTitleOf(action.itemId), + detail: { internal: true, note: say }, + }); + return { runtime, status: 'running' }; + } + throw new Error(say); } const ready = readyToWork(finishModel, runtime, action.itemId); await deps.memory.append({ @@ -1745,6 +1846,7 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { : [ `【当前这一步 · ${current.item}】${current.intent}`, currentTouch, + answeredCardFact(trail), current.guide, current.writes.length === 0 ? '' : `这一步要写的台账:${current.writes.join('、')}`, current.tools.length === 0 ? '' : `这一步要调的工具:${current.tools.join('、')}`, @@ -1976,7 +2078,8 @@ export function createTurnRunner(deps: TurnRunnerDeps): LoopEngineService { const step = stepOf(itemId); if (step?.doneWhen === undefined || step.doneWhen.trim() === '') return undefined; try { - return deps.sfeel.condition(step.doneWhen, liveScope); + const ok = deps.sfeel.condition(step.doneWhen, liveScope); + return ok ? { ok, why: '' } : { ok, why: unmetWhy(step.doneWhen, liveScope) }; } catch { // 谓词写坏了不该拖垮整拍(同 1436 行的口径):算不出来就不拦 return undefined; diff --git a/apps/api/src/modules/org/CONTRACT.md b/apps/api/src/modules/org/CONTRACT.md index 3b1d849..a1e28bc 100644 --- a/apps/api/src/modules/org/CONTRACT.md +++ b/apps/api/src/modules/org/CONTRACT.md @@ -59,3 +59,8 @@ `RosterSyncOutcome` 增 `failed`(契约变更,api-report 已刷新,`docs/API文档-鉴权与人员.md` §3/§7 同步); `AccessLockoutError` / `assertNotLockedOut` 收可选 `message`(两个来路各说各的话)。 下游 depcruise 反查:`rosterSyncOutcomeSchema` 只被 `syncStaffRoute.output` 与本模块用,web 尚无消费方。 + +影响半径(2026-08-26,姓在前;2026-08-27 合并 feat/act-work-05 时补记):`VerifiedClaims` 增可选 `given_name` / `family_name` + (Keycloak 拼好的 `name` 是「名 姓」西式全名,展示「姓 名」得拿散件自己拼;两个散件都缺才回退 `name`), + `identityOf` 与 `createKeycloakRoster`(`lastName firstName`)同一把尺。 + 加的是可选列,非破坏性;api-report `org/port.d.ts` 随合并刷新(主支那条提交没刷)。 diff --git a/docs/ACT-WORK-05-端到端测试记录.md b/docs/ACT-WORK-05-端到端测试记录.md new file mode 100644 index 0000000..9981c0f --- /dev/null +++ b/docs/ACT-WORK-05-端到端测试记录.md @@ -0,0 +1,288 @@ +# ACT-WORK-05 差异评估 —— 端到端测试记录 + +> 这份文档记的是**每一轮实跑逼出了什么、改了什么、怎么验证的**。 +> 活动包:`activities/part-substitution-assessment`;业务出处 `docs/SS02-ACT-WORK-05-html/`。 +> 台账字段口径见 `docs/数据域字段说明-W05.md`。 +> 走查分两条线:**浏览器**(测试台起单 → 工作台真人点,六轮)与**脚本 e2e** +> (`node tools/e2e-a2.mjs w05`,五案例代答,可一键复跑)。两条线逮到的缺陷不重合 —— +> 浏览器逮呈现与交互(件、闸、徽标、翻页、画面切换),脚本逮机制(空手交卷、循环、崩、归属)。 + +## 一、这个活动是什么 + +原 PN 与候选替代料之间**逐项差异评估**:比参数、判四态(MATCH / MISMATCH / UNKNOWN / CONDITIONAL)、 +定推荐等级(preferred / alternate / conditional / not_recommended)、留证据与验证任务, +最后把结论落进 P-11(替代关系 + 差异明细)并回写 P-01 需求,发射 `assessment-released` 交 ACT-GATE-03 评审。 + +**九个计划项**(五处不给 doneWhen —— 触达人的一律交人收): + +| 项 | 谁办 | 卡 / 件 | doneWhen | +|---|---|---|---| +| `S0_bind` | AI | —— | 有 | +| `S0d_p08_master` | 人 · 数据工单 | `p08-master-create`(表1 芯片主数据 + 表2 标准化参数集) | 无 | +| `S0d_p10_document` | 人 · 数据工单 | `p10-document-create`(原厂技术资料) | 无 | +| `S1_input_confirm` | 人 · 执行工单 | `eval-input-list`(评估输入清单) | 无 | +| `S2_normalize` | AI | —— | 有 | +| `S3_assess` | AI + 两枚工具 | —— | 有 | +| `S4_review` | 人 · 决策卡(可循环) | `difference-review` | 无 | +| `S5_prepare_landing` | AI | —— | 有 | +| `T_release` | 人 · 终局验收 | `landing-confirm` | 无 | + +## 二、逐轮走查 + +### R1 · 样例「都在库·常路」 + +**第 1 次 —— 熔断**,逮到两条真缺陷: + +- 轨迹里 `S0_bind` 写完三张表后连续 5 拍只做一件事「弃用计划项 `S0d_p08_master`」,每拍被拒 + 「生命周期迁移非法:Available → Disabled」→ 熔断交人;工作区还摆着一张「待建 0 条记录」的空数据工单件。 +- **根因一(平台事实,本轮不改)**:`lifecycle.ts` 里 `Disabled` 只能从 `Enabled` 来,而 `Enabled` 只由 + `plan` 动作写;普通计划项一直停在 `Available`。全仓只有本活动用过 `disable` —— **这条路从没人走通过**。 +- **根因二(活动缺陷,已修)**:哨兵 `s_bound` 只看「需求写了 + 核对表写了」,而 `S0_bind` 在**每条路**上都写这两张表, + 于是都在库时数据工单那两项照样进「当下可为」,剧本就让模型去 disable。 +- 修:哨兵加 `sub_eval_pn_check_exists_status_absent > 0`;全包清 `disable`;两条回归测试。**v1.0.1**。 + +**第 2 次 —— 通了**:两拍写完 `demand.request` / `pn_check` / `verdict`,直接派出执行工单; +提交闸如实拦住空手交卷并点名三条缺项(与件上红带同名同数);填三格保存 → 闸自收 → 提交。 + +**收工:`released` · 12 拍 · 人环 3 · 行动被拒 0**。落账逐条 SQL 核过: + +- P-11 主记录 1 条:`pin_to_pin | alternate | fae_confirmed | 客批=(空) | R-2026.07` —— **客户批准状态确实留空**(只读边界守住),规则版本随结论落账; +- P-11 差异明细 9 条(8 MATCH / 1 CONDITIONAL);P-01 回写五项齐;出口 `assessment-released` 已发射; +- 验收卡 11 条判据全部达标(L1×2 / L2×6 / L4×3),一次通过。 + +### R2 · 样例「候选缺库·派数据工单」 + +四次开跑,逼出四条缺陷(E / F / G / H),逐条治了再跑;第 4 次(v1.2.3)全绿。 + +| 次 | 版本 | 结果 | 逼出什么 | +|---|---|---|---| +| 1 | 1.2.0 | 中途停 | E(决策卡被跳过)已在本次前修好并当场验证;F 现形 | +| 2 | 1.2.1 | 熔断 | F 修复通过;**G 现形**(`recommend` 工具被跳过 → S3 收步恒假) | +| 3 | 1.2.2 | 中途停 | G 修复通过;**H 现形**(压拍发卡,清单一行没有) | +| 4 | 1.2.3 | **`released` · 被拒 0 · 人环 5** | 四条修复全部实测通过 | + +第 4 次逐段实证: + +- 决策卡按规格出现(候选总数 2 ≥ 2)→ 答「创建主数据」; +- P-08 数据工单**一件两表**(主数据 1 行 + 参数 6 行),两张表各有自己的编辑闸与缺项红带; + 填好保存 → 提交 → **画面自己切到 P-10**(发现 F 的修复稳定); +- **执行工单出来时清单已有 12 行**(上一轮是 0)—— 发现 H 的修复见效;提交闸如实拦住剩下那条 + 「未披露」缺口,补上才放行 —— 闸与件同源; +- **S3 两枚工具都真调了**(轨迹里 `compare-parameters 返回` / `recommend 返回` 各一条),自动收步,没有熔断; +- **审核驳回循环**(本轮顺带覆盖):在「写下你的口径」里写两条具体意见 → 模型改台账 → **换问法重发**新卡。 + 逐条核过落点:XL2596S-5.0 降 `conditional`、两条 UNKNOWN 明细写明处置(挂 `VAL-…` 验证任务、 + 「闭环前不升级推荐等级」)、LM2596S-ADJ 的推荐理由点名「R1/R2 分压电阻」—— **意见落在被点名的那两处**; +- 终局验收 11 条判据全部达标 → 确认通过 → `released`。 + +落账 SQL 复核:P-11 两条关系(`pin_to_pin | conditional | fae_confirmed` / `pin_to_pin | alternate | fae_confirmed`, +客批均空、规则版本 `R-2026.07`)· 差异明细 18 条(15 MATCH / 2 UNKNOWN / 1 CONDITIONAL)· +验证任务 1 条(`not_started`)· P-01 回写五项齐 · **XL2596S-5.0 真进了主数据**(`XLSEMI | active`,6 行参数 + 1 份资料)。 + +### R3 · 样例「三候选·含硬约束不推荐」—— `released` · 被拒 0 + +一次跑通,验的是**硬约束这条路**: + +- 决策卡按规格出现(3 颗候选,只有 CN-DCDC-32V 缺库)→ 建主数据 → P-08 填 + **输入电压范围 4.5~32(hard)**、工作温度 -20~+85(hard); +- 清单 13 行、三行 default 的 detail 写对了默认值本身;缺口里把客户约束写成可解析式「输入上限硬指标 >= 40(V)」; +- S2 铺 3 条关系 + 27 条明细;S3 两枚工具都调过; +- **CN-DCDC-32V = `not_recommended` / high**(两条硬约束 MISMATCH:输入 4.5~32 vs 4.5~40、温域 -20 vs -40), + XL2596S-5.0 `conditional`、LM2596S-ADJ `alternate`; +- 验收件上三颗候选各一份「拟写 P-11」字段表,徽标逐个核过(不推荐/高 · 条件推荐/中 · 备选/中 · Pin-to-Pin · FAE确认)。 + +**一次自纠**:我先按 `innerText` 判定「四个枚举列是空的」,险些记成缺陷 —— +徽标文字是 CSS `::after` 生成的,`innerText` 读不到。**验证呈现要看 computed style,不看 innerText**。 + +### R4 · 样例「原PN缺库·硬阻塞」 + +三次开跑,逼出两条**同族**的真缺陷: + +**第 1 次(v1.2.3)—— 发现 I:「在库」是模型自报的一句话** + +原 PN `LM2596S-3.3` 主数据里**一行都没有**(SQL 复核 count = 0),模型把原 PN 与候选**两颗都写成 `found`**, +交代里还写「原 PN 与候选都在库」—— 数据工单一张没派,直接把评估输入执行工单发给了人。 +剧本早写着「`parts.profile` 整表在你的作用域里,按 internal_pn 逐个核对」——**措辞已到头**。 + +**结构治**:`sub_eval.pn_check` 加一列 `found_pn_ref`, +`refersTo: parts.profile.internal_pn` + `requiredWhen: {exists_status: found}`。 +于是「判在库」这句话必须配一个**基座拿去主数据里查得到**的料号: + +- 查无此值 → `draftWrite` 当场拒; +- 填不出 → `pn_check_missing > 0` → `S0_bind` 的 `doneWhen` 收不掉。 + +两条路都堵死,唯一走得通的就是如实写 `absent`。**这是「机检只读基座数」第六次现形** +(前五次是 missing_key_total / missing_minor_total / untyped_total / draft_total / 哨兵读 line_total), +这次的形状不是计数,是**存在性**。 + +**第 2 次(v1.2.4)—— 墙生效了,但逮出发现 J:数据工单派给了在库的那颗** + +核对表这次写对了(`LM2596S-3.3 = absent`、`LM2596S-ADJ = found` 且依据经基座查过), +可数据工单派给了 **LM2596S-ADJ**(它在库、参数资料齐全),真正缺的那颗没人建。 +交代原话:「候选只有 LM2596S-ADJ 一颗,按规则直接建主数据」—— +它把「候选总数 = 1 → 不问人」这条**关于问不问**的规则,读成了**关于建哪颗**的规则。 +病根:剧本把两个问题写在同一串项目符号里,三档分岔每档都以「→ 直接进入建的名单」收尾, +而**从没写过「found 的不建」**。与发现 E 同形。 + +**治法(措辞,精准化)**:拆成「**问题一 · 建哪几颗**」(名单 = `absent` 的每一行,`found` 的一行都不建,并写明后果) +与「**问题二 · 建之前要不要先问人**」(只有 absent 的候选才谈得上问)。这一处不上结构 —— +系统其实兜得住(原 PN 还 absent → S1 哨兵不开 → 依赖断点),只是要白烧一次人环; +而这一刀是**补上从没写过的那句话**,不是把已经写过的话再说一遍。 + +**第 3 次(v1.2.5)—— `released`**:数据工单派给了 `LM2596S-3.3`,**没发决策卡**(硬阻塞不问人),两条修复都实测通过。 + +这一轮还留下了**发现 I 那道墙开火的现场证据**(轨迹 seq 6): + +> 行动被拒:在库核对依据「LM2596S-3.3」在芯片主数据(P-08)里不存在 —— 这一列只许引用台账里真实存在的值…… + +模型确实又想判「在库」,基座当场拒回并点名;它随后如实写了 `absent`,硬阻塞照规格走了下去。 + +**终局「重做」分支也在这一轮验了**(本活动此前未验):在验收卡上写明两条意见后点「重做」—— +模型没有原样再递一次,而是**真去改了台账**(`demand.request.verification_requirement` 重写、 +5 行 `difference_item.evidence_ref` 从「只写文件名」改成指到 `Rev H (2023-09) §6.5 Electrical Characteristics`), +再重新裁量 + 提交;第二张验收卡确认通过 → `released`。 + +整单 2 次被拒:一次是上面那道墙(它该拒),一次是 S3 的「先 finish 后调工具」—— +拒回文案照旧只谈「行与列」(平台欠账已记),但模型下一拍自己去调了 `recommend`、随即自动收步,没有熔断。 + +落账:`parts.profile.LM2596S-3.3`(TI / nrnd,7 行参数)真进了主数据; +P-11 一条(`LM2596S-3.3 → LM2596S-ADJ | alternate | fae_confirmed`);P-01 回写齐。 + +### R5 · 样例「新客户·先建档」 + +验的是**数据录入卡**这条路(客户不在档案里,先收人、再评估): + +- 卡按规格出现:「客户 CU-9001 不在客户档案里,请核对建档信息后确认」,客户名称已从入参带出、行业与区域留白给人补; +- 补两格 → 确认写入 → 客户档案落草稿层(`深圳恒星电源有限公司 / 工业电源 / 华南`)→ 流程直奔 S1(两颗料都在库); +- 缺口补齐 → 审核通过 → 终局确认 → `released`。 + +**发现 K**:那张录入卡的「参考信息」栏摆的是引擎兜底的**内部家具** —— +「这一步 / 当下可为 / 目标缺口」,后面跟着**九个计划项的全名**,人一个字用不上。 +病根:`entryCard.basis` 在契约里是**可选**的,活动的卡骨架没声明,基座就把内部事实兜了上去。 +与 A1 2026-08-03 那次同族(那次是执行卡的 steps/standard 没进说明书)。 +治法:说明书里的录入卡骨架补 `basis` 三行(触发原因 / 这一单要评估的 / 确认之后会发生什么), +并在骨架下写明「不给基座会兜内部家具」。配一条测试。 + +**一处操作教训(不是缺陷)**:测试台在「清场」之后会回落到样例 0 —— +选样例与「起单试跑」必须在同一次操作里完成,否则起的是上一个默认样例。 + +## 二·五、六轮走查一览 + +| 轮 | 样例 | 结果 | 这一轮覆盖的分支 | +|---|---|---|---| +| R1 | 都在库·常路 | `released` · 12 拍 · 人环 3 · 被拒 0 | 无数据工单直通;验收判据 11/11 | +| R2 | 候选缺库·派数据工单 | `released` · 被拒 0 · 人环 5 | 决策卡(创建)· P-08 一件两表 · P-10 · **审核驳回循环** | +| R3 | 三候选·含硬约束不推荐 | `released` · 被拒 0 | 三候选并行 · **硬约束 MISMATCH → `not_recommended`** | +| R4 | 原PN缺库·硬阻塞 | `released` · 被拒 2(其中一次是墙该拒) | **硬阻塞不问人** · **终局「重做」循环** | +| R5 | 新客户·先建档 | `released` · 被拒 1 | **数据录入卡建档** | +| R5b | 新客户(v1.2.6) | 验完即停 | 录入卡 `basis` 呈现 | + +版本轨迹:1.0.0 → 1.0.1(A)→ 1.1.0/1.1.1(B·C·D)→ 1.2.0(参数子表)→ 1.2.1(F)→ 1.2.2(G) +→ 1.2.3(H)→ 1.2.4(I)→ 1.2.5(J)→ **1.2.6(K)**。包内自测 16 → **61 条**。 + +## 二·六、脚本 e2e 的六轮(2026-08-27) + +浏览器那六轮之后,凭证到位、`w05` 套件跑起来,又逼出六条 —— **全是浏览器逮不到的那一类** +(脚本每张卡都先空手交一次、每个岔路口都按序代答,人手点的时候会先把格子填好再按提交): + +| 轮 | 结果 | 这一轮逼出什么 | +|---|---|---| +| 1 | 1 通过 | **L 数据工单的提交闸没牙** | +| 2 | 3 通过 | **M 拒回数不出「缺的是一次工具调用」· N 决策卡拒回只给指针** | +| 3 | 1 通过 | N 的措辞版没用 → **改结构**;**O 工具被 null 打崩** · P `count` 假线索 | +| 4 | 2 通过 | **H 的残留面:零行同时骗过闸与哨兵** | +| 5 | 4 通过 | **created 逐颗对账太松 · S1 卡的前提没写在说明书** | +| 6 | 跑到的 4 例全 released,3 例被拒 0 | 案例 4 停在 `Insufficient Balance`(大模型余额) | +| 7 | 前 3 例 released | 充值后:先撞上我自己拉起的旧稳定实例抢单(`recommend` 无可用实现);**T** P-10 骨架零行 · **U** 脚本一例翻车整套退出 | +| 8 | **5 例全 released,4 例被拒 0** | 案例 3 被拒 6:**V** 建完第一颗就收掉数据工单那一项 | +| 9 | 案例 3 单跑 | 用户纠正「别每次全跑」;逮到一次**假绿**:**W** 参数名写成英文 key · **X** 两颗缺库只问一次 —— 断言收紧 | +| 10–11 | 案例 0/1 被拒 0 | **W 的乘法对账只在 ≥2 颗时咬得住**,单颗照漏 → 自指 `refersTo`;**Y** 脚本按闸的指示「加一行」;案例 2 撞 **Z** | +| 12 | 案例 2 · 4 各单跑 | **Z** 修后 released · 被拒 0 · 卡先发人再答 | + +**最终状态(收紧断言下)**:五例全部 `released` · 全部被拒 0。 +案例 0/1 验于 1.3.5、案例 3 验于 1.3.4、案例 2/4 验于 1.3.6 —— 1.3.6 只改了 S0d 剧本里「何时标 created」那一句, +案例 0/3 走过那一步、未在最终文本上复验(如实记)。 + +第 6 轮逐条实证:早收容忍让案例 1/2 的最后 1 次被拒消失(轨迹里是**观察**不是拒回); +三候选那例**第一次跑通**(前三轮:超时 / 超时 / 烧穿预算),两颗缺库一起办、三条结论全对。 + +## 三、走查发现总表 + +| # | 现象 | 病根 | 治法 | 层 | +|---|---|---|---|---| +| A | 缺口表**每一行**都摆红「必填」,而闸只认 3 条 | 那一格用静态 `req` class,`supplement` 的声明是 `requiredWhen:{status:'gap'}` | 按行投影 `data-class-of="status"`,判断留样式表 | 活动 | +| B | 五张模版是 E04/I01 的 `jc-rp-*` 外壳,不是目标件的版面 | 计划文本自相矛盾(一边说逐字量自目标件,一边让用 `prd-style.ts`) | 目标件 `