XiaChangSong/BPOS-TMP-REPO
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(w05): 重判的行由确定的一侧圈 —— 打回点名工作温度,不许去改静态电流

Browse Source 
用户实测:「我打回让修改工作温度的结论,给我改了静态电流的结论」。库里的证据一字不差:
工作温度它没改(还给了理由:候选值 1℃ 远窄于 -40~+85℃,硬约束不满足 —— 这半截是对的),
而没人问过的静态电流被它从 soft_mismatch 翻成 match,evidence_note 里却写着「维持原判」。

根因不是提示词不够严,是**整表交出去、整表写回来**:没有任何东西限制它只动被点名的那一行,
而「我只改了那一条」这句话本身也出自它嘴里。规范 §4.6 纪律一(行由确定的那一侧决定,
不由 AI 决定)—— 昨天刚加的重判轮自己栽在这条上。

S3 复核轮两笔变四笔(全部只在 case_redo_note != "" 那一轮跑):
① 圈范围:按字面点名(contains,与基座给模型摆的「意见点名对上了哪几行」同一种认法)标
   named / kept(明细表新增 redo_scope 列);
② 兜底:一条都没点到(意见说的是整批)→ 整表算被点名,读上一笔刚写下的 tally,不重算;
③ 重判只喂 named 的行 —— 没点名的行 AI 连见都见不到,自然改不着(也省 token);
④ 写回也只写这几行;模型漏答某一条时 else 兜回它上一轮的值。

同批修一条挡了两次路的老毛病(昨夜刚记 debt,今晚又撞停、还卡住了我自己的验证):
人答得比发卡那一拍收尾还快时,回传被判 stale、wake 又被那一拍的 park 覆盖,单子停在
awaiting-event 再没人叫醒。deliver 判了 stale 照旧不跑这一拍,但把停着的单子拨回 running。

验收:e2e w05 5/5 released、被拒 0;案例 0 新断言「打回只动了被点名的那几条,其余行一个字没变」
真跑通过(途中逼出脚本自己的坑:放行会清空草稿层,快照得留在放行之前);
模型调用 案例 0 = 2 次、其余 = 1 次。四处变异验证。W05@2.18.0 已装库。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LKMZDwMbyKzjw6Hembwvet
This commit is contained in:
xcs
2026-09-01 01:17:09 +08:00
co-authored by Claude Fable 5
parent 4d2c3657f9
commit 8314148ebc
8 changed files with 320 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
activities/part-substitution-assessment/__tests__/steps.test.ts
+56 -26
View File
@@ -406,12 +406,11 @@ describe('S3 / S4 配方', () => {
const s4 = stepOf('T_release')?.auto?.do ?? [];
const s2 = stepOf('S2_assess')?.auto?.do ?? [];
it('S3 七笔:复核重判 → 落明细 → 明细重算 → 关系 → 验证记录 → 卡 → 交代', () => {
expect(s3.map((a) => a.kind)).toEqual(['analyze', 'project', 'project', 'project', 'project', 'card', 'say']);
expect(s3[1]?.kind === 'project' && s3[1].into).toBe('substitution.difference_item');
expect(s3[2]?.kind === 'project' && s3[2].into).toBe('substitution.difference_item');
expect(s3[3]?.kind === 'project' && s3[3].into).toBe('substitution.relation');
expect(s3[4]?.kind === 'project' && s3[4].into).toBe('validation.record');
it('S3 九笔:圈范围 → 兜底扩范围 → 复核重判 → 落明细 → 明细重算 → 关系 → 验证记录 → 卡 → 交代', () => {
expect(s3.map((a) => a.kind)).toEqual(['project', 'project', 'analyze', 'project', 'project', 'project', 'project', 'card', 'say']);
for (const at of [0, 1, 3, 4]) expect(s3[at]?.kind === 'project' && s3[at].into).toBe('substitution.difference_item');
expect(s3[5]?.kind === 'project' && s3[5].into).toBe('substitution.relation');
expect(s3[6]?.kind === 'project' && s3[6].into).toBe('validation.record');
});
/*
@@ -422,25 +421,56 @@ describe('S3 / S4 配方', () => {
* 只在被打回的那一轮跑:`case_redo_note` 是引擎注给配方的那句话(没打回就是空串)——
* 常路(第一次送审)这两笔跳过,整个活动仍然只调一次模型。
*/
it('复核轮:两笔都钉在「人打回了才跑」上,判法与第一轮同一份规矩,入参多带上一轮结论与他的意见', () => {
const redo = s3[0];
const land = s3[1];
expect(redo?.kind === 'analyze' && redo.when).toBe('case_redo_note != ""');
expect(land?.kind === 'project' && land.when).toBe('case_redo_note != ""');
it('复核轮四笔都钉在「人打回了才跑」上 —— 常路一笔都不跑,整单仍只调一次模型', () => {
/* `when` 不是每一种笔都有的键 —— 按「有没有这个键」取,不做属性访问(与本文件既有的 `'prune' in …` 同一写法) */
const whenOf = (at: number): unknown => {
const act = s3[at];
return act !== undefined && 'when' in act ? act.when : undefined;
};
for (const at of [0, 1, 2, 3]) expect(String(whenOf(at) ?? ''), `第 ${at} 笔`).toContain('case_redo_note != ""');
/* 后面那几笔(重算 / 关系 / 验证)照旧每一轮都跑 —— 人就地改了四态也要跟着重算 */
for (const at of [4, 5, 6]) expect(whenOf(at), `第 ${at} 笔`).toBeUndefined();
});
/*
* **谁可以变,由确定的一侧圈**(2026-09-01 用户实测:「我打回让修改工作温度的结论,给我改了
* 静态电流的结论」)—— 第一版把整表交给 AI 重判、整表写回,没有任何东西限制它只动被点名的
* 那一行;它改了没人问过的那条,`evidence_note` 里还写着「维持原判」。
* 现在:①按字面点名圈出 `named`;③入参**只有** `named` 的行;④写回也只写这几行。
*/
it('圈范围:点名的标 named,其余 kept;一条都没点到时整表算被点名', () => {
const mark = s3[0];
const widen = s3[1];
const markFields: Readonly<Record<string, unknown>> = mark?.kind === 'project' ? mark.fields : {};
expect(markFields['redo_scope']).toEqual({ when: 'contains(case_redo_note, parameter_name)', then: 'named', else: 'kept' });
/* 兜底那一笔读的是上一笔刚写下的 tally 读数 —— 不重新算一遍谁被点到 */
expect(widen?.when).toBe('case_redo_note != "" and substitution_difference_item_redo_scope_named = 0');
expect(widen?.kind === 'project' ? widen.fields['redo_scope'] : undefined).toBe('named');
});
it('重判与写回都只认 named 的行 —— 没点名的行 AI 连见都见不到,自然改不着', () => {
const redo = s3[2];
const land = s3[3];
const named = { each: 'mine:substitution.difference_item', where: { redo_scope: 'named' } };
expect(redo?.kind === 'analyze' ? redo.input.from : undefined).toEqual(named);
expect(land?.kind === 'project' ? land.from : undefined).toEqual(named);
/* 判法一处真源:复核指令以第一轮那份规矩打头,后面才接复核纪律 */
const first = s2[0];
const rules = first?.kind === 'analyze' ? first.instruction : '';
const rules = s2[0]?.kind === 'analyze' ? s2[0].instruction : '';
expect(redo?.kind === 'analyze' && redo.instruction.startsWith(rules)).toBe(true);
expect(redo?.kind === 'analyze' && redo.instruction).toContain('原样带回');
/* 入参:上一轮四态 + 他写的意见 —— 少了任何一样,重判要么冲掉人改过的行,要么读不到意见 */
const fields = Object.keys(redo?.kind === 'analyze' ? redo.input.fields : {});
/* 入参:上一轮结论 + 他写的意见 —— 少了任何一样,重判要么无据可依,要么读不到意见 */
const fields: Readonly<Record<string, unknown>> = redo?.kind === 'analyze' ? redo.input.fields : {};
for (const key of ['last_status', 'last_impact', 'last_evidence', 'last_unknown_disposition', 'reviewer_note']) {
expect(fields).toContain(key);
expect(Object.keys(fields)).toContain(key);
}
expect(redo?.kind === 'analyze' && redo.input.fields['reviewer_note']).toEqual({ in: 'case_redo_note' });
/* 落明细那一笔与第一轮同一份投影(只多一个 when)—— 各写一份早晚分叉 */
const s2Land = s2[2];
expect(land?.kind === 'project' && land.fields).toBe(s2Land?.kind === 'project' ? s2Land.fields : undefined);
expect(fields['reviewer_note']).toEqual({ in: 'case_redo_note' });
/* 模型漏答某一条:兜回这一行上一轮的值 —— 漏答不该变成「把它清空」 */
const landFields: Readonly<Record<string, unknown>> = land?.kind === 'project' ? land.fields : {};
for (const col of ['difference_status', 'impact_statement', 'evidence_note', 'unknown_disposition']) {
expect(landFields[col]).toMatchObject({ lookup: 'result:items', else: { col } });
}
/* 派生列与两处创建笔共用同一份 when 链 */
const s2Fields: Readonly<Record<string, unknown>> = s2[2]?.kind === 'project' ? s2[2].fields : {};
expect(landFields['judgement_class']).toBe(s2Fields['judgement_class']);
});
/*
@@ -450,7 +480,7 @@ describe('S3 / S4 配方', () => {
* `s3[0]` 必须是**排在关系 / 验证记录投影之前**的差异明细重算笔。
*/
it('差异明细重算笔:只列主键与两个派生列,不碰 difference_status 自己、也不碰人能改的叙事列', () => {
const recompute = s3[2];
const recompute = s3[4];
expect(recompute?.kind === 'project' && recompute.from).toEqual({ each: 'mine:substitution.difference_item' });
/* `recompute` 经 `s3[0]` 的 tuple 定位精确 narrow 到这一笔自己的字面量类型,它压根没有
`prune` 这个键(不是「值为 undefined」,是键不存在)—— `in` 判存在性,不做属性访问 */
@@ -468,7 +498,7 @@ describe('S3 / S4 配方', () => {
* 展开)——各写一份早晚分叉,而分叉的那一刻屏上会同时摆着两个互相矛盾的规则。
*/
it('S3 重算笔与 S2 差异明细创建笔共用同一份 judgement_class / risk_level when 链', () => {
const s3Fields = s3[2]?.kind === 'project' ? s3[2].fields : undefined;
const s3Fields = s3[4]?.kind === 'project' ? s3[4].fields : undefined;
const s2Fields = s2[2]?.kind === 'project' ? s2[2].fields : undefined;
expect(s2Fields?.['judgement_class']).toBeDefined();
expect(s3Fields?.['judgement_class']).toBe(s2Fields?.['judgement_class']);
@@ -489,7 +519,7 @@ describe('S3 / S4 配方', () => {
* 「人改四态 → 等级跟着变」这条链不能断),且与 S2 那份是**同一个 when 链引用**(不许分叉)。
*/
it('**S3 的关系笔只重算判定** —— 收口四格(理由/摘要/风险/验证要求)一列都不许出现,否则人改完一保存就被冲掉', () => {
const relation = s3[3];
const relation = s3[5];
expect(relation?.kind).toBe('project');
const fieldsOf = (act: (typeof s3)[number] | undefined): Readonly<Record<string, unknown>> =>
act?.kind === 'project' ? act.fields : {};
@@ -504,7 +534,7 @@ describe('S3 / S4 配方', () => {
/* 主键带回:同 PK 覆盖,不是新开一行 */
expect(fields['substitution_relation_id']).toBeDefined();
/* 验证记录那一笔仍与 S2 同一份(它不涉及人可改的格子) */
expect(s3[4]).toBe(s2[4]);
expect(s3[6]).toBe(s2[4]);
});
/*
@@ -520,7 +550,7 @@ describe('S3 / S4 配方', () => {
});
it('S3 的卡:审核面孔、单一选项、挂本步的件', () => {
const card = s3[5];
const card = s3[7];
expect(card?.kind === 'card' && card.as).toBe('decide');
expect(card?.kind === 'card' && card.variant).toBe('review');
expect(card?.kind === 'card' ? card.options ?? [] : []).toHaveLength(1);