Archived
fix(w05): 重判的行由确定的一侧圈 —— 打回点名工作温度,不许去改静态电流
用户实测:「我打回让修改工作温度的结论,给我改了静态电流的结论」。库里的证据一字不差: 工作温度它没改(还给了理由:候选值 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
@@ -1834,6 +1834,39 @@
|
||||
.dossiers 三列网格(1fr·76px·1fr),中间列是实体动画道 —— ⇄ 徽呼吸 + 双点绕徽轨道
|
||||
对转(sw-orbit),总线虚线在道里连两卡;窄屏单列收道。浏览器两帧相位实证。
|
||||
|
||||
- **答得太快就没人再叫醒它 —— stale 那条守卫补最后一下**(2026-09-01,一夜之内撞停两次,
|
||||
第二次直接把我自己的验证卡住 15 分钟):卡发出 **270ms** 后人就答了,而**把 `lastProgressAt`
|
||||
往前挪的那一拍,正是发出这张卡的那一拍** —— 它不可能消费一条当时还不存在的回传,
|
||||
2026-08-27 那条 stale 守卫的前提(「推进过 = 回传已被消费」)在这种时序下不成立;
|
||||
回传口的 `wake` 也白做了(那一拍随后收尾,把任务 park 回 `awaiting-event`,晚到的写盖了早到的)。
|
||||
三样凑齐:卡答完了、没有新卡在等、单子停着 —— **再没有第三样东西会叫醒它**
|
||||
(手工把 runtime 拨回 running,同一份代码立刻把该走的几拍走完)。
|
||||
修:`deliver` 判了 stale **照旧不跑这一拍**(它的本意不变),但把停着的单子拨回 `running`
|
||||
交给推进器;真没事可干,它自己再停回去(代价一拍空转)。两条测钉死 + 变异验证。
|
||||
真人点卡要几秒,撞不上这条窗口;**e2e 是 3 秒轮询 + 秒答,专把这种窗口撞出来** ——
|
||||
它替人踩的正是这一类。
|
||||
|
||||
- **「我打回让改工作温度,它给我改了静态电流」—— 重判的行由确定的一侧圈,不由 AI 决定**
|
||||
(2026-09-01 用户实测,`part-substitution-assessment@2.18.0`)。上一条刚把意见交回给 AI 重判,
|
||||
当天就被这一单打脸,而库里的证据一字不差:**工作温度它没改**(还给了理由:候选值 1℃ 远窄于
|
||||
-40~+85℃,硬约束不满足 —— 这半截是对的),而**没人问过的静态电流**被它从 soft_mismatch
|
||||
翻成 match,`evidence_note` 里却写着「**维持原判**」。两张审核卡的「本轮结论」都还停在
|
||||
S2 那一版(0 项一致 / 5 硬 / 2 软),而草稿此刻是 1 match / 5 硬 / 1 软 —— 差的那一项就是它。
|
||||
**根因不是提示词不够严,是整表交出去、整表写回来**:没有任何东西限制它只动被点名的那一行,
|
||||
而「我只改了那一条」这句话本身也出自它嘴里(它说了「维持原判」,可它改了)。规范 §4.6 纪律一
|
||||
——**行由确定的那一侧决定,不由 AI 决定** —— 这次栽在自己手上。
|
||||
治法(S3 复核轮从两笔变四笔,全部只在 `case_redo_note != ""` 那一轮跑):
|
||||
①**圈范围**:按字面点名(`contains(case_redo_note, parameter_name)`,与基座给模型摆的
|
||||
「意见点名对上了哪几行」同一种认法)把行标成 `named` / `kept`(明细表新增 `redo_scope` 列,tally);
|
||||
②**兜底**:一条都没点到(「结论整体判得太松」这类意见说的是整批)→ 整表算被点名,
|
||||
读的是上一笔刚写下的 tally 读数,不重新算一遍;③**重判只喂 `named` 的行** ——
|
||||
没点名的行 AI 连见都见不到,自然改不着(也省 token);④**写回也只写这几行**,
|
||||
模型漏答某一条时 `else` 兜回它上一轮的值(漏答不该变成「把它清空」)。
|
||||
两处变异各自验证(写回不过滤 / 圈范围时一律标 named,都当场变红)。
|
||||
e2e 案例 0 加一条**跨轮比对**断言:打回前存一份明细,放行前留最后一份,
|
||||
逐行比「名字没出现在意见里的行,四态与三段叙述一个字都不许变」——
|
||||
途中还逼出脚本自己的一个坑:**放行会清空草稿层**,收工时再取明细什么都没有,快照得留在放行之前。
|
||||
|
||||
- **重做的意见现在真交回给 AI 重跑那一步**(2026-09-01 用户:「唯一调用 ai 的这一步,使用重做后
|
||||
是否没有将重做原因带回去重新让 ai 重跑?」——**确实没有**:S3 那一轮只把派生列重算一遍,
|
||||
人写的那句话除了留痕之外无人读,AI 判过的四态一个字不会变,除非他自己在件上逐格改)。
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -428,17 +428,56 @@ const DIFFERENCE_ITEM_FROM_RESULT = {
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* **人把结论打回时,意见要交回给 AI 重判 —— 这是整个活动第二次(也是最后一次)出场**
|
||||
* (2026-09-01 用户定:「重做后是否没有将重做原因带回去重新让 ai 重跑这一步?」——
|
||||
* 当时确实没有:S3 那一轮只把派生列重算一遍,人写的那句话除了留痕之外无人读)。
|
||||
* ── 复核轮(人把结论打回那一轮)的四笔 ──────────────────────────────────
|
||||
*
|
||||
* 只在被打回的那一轮跑:`case_redo_note` 是引擎注给配方的「人这次打回写了什么」
|
||||
* (没打回就是空串,永远绑得上 —— 见 `auto-runner.ts` 的 `AutoContext.redoNote`)。
|
||||
* **背景**:2026-09-01 第一版做成了「把意见连同整表交回给 AI 重判」,当天就被用户实测打脸:
|
||||
* 「我打回让修改**工作温度**的结论,给我改了**静态电流**的结论」。库里的证据一字不差 ——
|
||||
* 工作温度它没改(还给了理由:候选值 1℃ 远窄于 -40~+85℃,硬约束不满足),
|
||||
* 而没人问过的静态电流被它从 soft_mismatch 翻成了 match,`evidence_note` 里却写着「**维持原判**」。
|
||||
*
|
||||
* **入参比第一轮多两样**:①上一轮的结论(四态 / 影响 / 依据 / UNKNOWN 去向)——
|
||||
* 人可能已经就地改过几行,那也是「上一轮结论」的一部分;②他这次写的意见。
|
||||
* 判法本身与第一轮**同一份** `ASSESS_RULES`,后面只接一段复核纪律:
|
||||
* **没被点到、也确实没判错的行原样带回**,别趁重判把人改过的东西悄悄冲掉。
|
||||
* **根因不是提示词不够严,是行由 AI 决定**:整表交出去、整表写回来,没有任何一样东西限制它
|
||||
* 只动被点名的那一行;「我只改了那一条」这句话本身也出自它嘴里,而它说的不作数。
|
||||
* 这正是规范 §4.6 纪律一 —— **行由确定的那一侧决定,不由 AI 决定**。
|
||||
*
|
||||
* **治法**:先由确定的一侧圈出「这一轮谁可以变」(①②),再把**只有这几行**交给 AI(③),
|
||||
* 写回也只写这几行(④)。没被点名的行 AI 连见都见不到,自然也就改不着。
|
||||
*/
|
||||
|
||||
/** ① 圈范围:人打回的那句话里点了名的行标 `named`,其余 `kept` —— 与基座给模型摆的「意见点名对上了哪几行」同一种认法(字面包含) */
|
||||
const REDO_SCOPE_MARK = {
|
||||
kind: 'project' as const,
|
||||
when: 'case_redo_note != ""',
|
||||
into: 'substitution.difference_item',
|
||||
from: { each: 'mine:substitution.difference_item' },
|
||||
fields: {
|
||||
substitution_relation_id: { col: 'substitution_relation_id' },
|
||||
difference_item_id: { col: 'difference_item_id' },
|
||||
redo_scope: { when: 'contains(case_redo_note, parameter_name)', then: 'named', else: 'kept' },
|
||||
},
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* ② 一条都没点到 → 整表都算被点名(「结论整体判得太松」这类意见说的是整批,不是某一条)。
|
||||
* 读的是上一笔刚写下的 tally 读数(每一笔之前刷读数)—— 不重新算一遍谁被点到,同一件事只许有一处判定。
|
||||
*/
|
||||
const REDO_SCOPE_WIDEN = {
|
||||
kind: 'project' as const,
|
||||
when: 'case_redo_note != "" and substitution_difference_item_redo_scope_named = 0',
|
||||
into: 'substitution.difference_item',
|
||||
from: { each: 'mine:substitution.difference_item' },
|
||||
fields: {
|
||||
substitution_relation_id: { col: 'substitution_relation_id' },
|
||||
difference_item_id: { col: 'difference_item_id' },
|
||||
redo_scope: 'named',
|
||||
},
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* ③ **带着意见重判 —— 只判被点名的那几条**(整个活动第二次、也是最后一次模型出场)。
|
||||
*
|
||||
* 入参直接来自明细表自己的行(参数名/说明/约束/单位/两侧的值/上一轮结论都在上面),
|
||||
* 外加人写的那句话;**没被点名的行压根不在这一批里**,所以「别去动它」不需要靠提示词求它。
|
||||
* 判法与第一轮**同一份** `ASSESS_RULES`,后面只接一段复核纪律。
|
||||
*/
|
||||
const REVIEW_REDO_ANALYZE = {
|
||||
kind: 'analyze' as const,
|
||||
@@ -448,36 +487,57 @@ const REVIEW_REDO_ANALYZE = {
|
||||
instruction: [
|
||||
ASSESS_RULES,
|
||||
'',
|
||||
'【这一轮是复核,不是从头判】上一轮的结论已经摆在每一条的 last_* 里,审核人写下的意见在 reviewer_note。',
|
||||
'· 意见点到的那几条:按他说的复核,该改就改,并在 evidence_note 里写清这一轮改了什么、依据是什么;',
|
||||
'· **意见没点到、你也确实没判错的**:把 last_* 原样带回来 —— 人可能已经在件上亲手改过几行,重判不是把它们冲掉的机会;',
|
||||
'· 他说的若与硬规矩冲突(比如要把证据不足的硬约束判成 match),照硬规矩judge,并在 evidence_note 里说明为什么不能照办。',
|
||||
'【这一轮是复核】下面**只列了审核人这次点到的那几条**(他写的话在 reviewer_note,每条都带着上一轮的结论 last_*)。',
|
||||
'· 按他说的复核这几条:该改就改,并在 evidence_note 里写清这一轮改了什么、依据是什么;',
|
||||
'· 复核下来确实是上一轮判对了,就把 last_* 原样带回,evidence_note 说明为什么维持;',
|
||||
'· 他要的若与硬规矩冲突(比如要把证据不足的硬约束判成 match),照硬规矩判,并在 evidence_note 里说明为什么不能照办;',
|
||||
'· **列出来的每一条都要回**,一条不多、一条不少。',
|
||||
].join('\n'),
|
||||
input: {
|
||||
from: { each: 'parts.type_param', where: { type_id: { in: 'typeId' } } },
|
||||
from: { each: 'mine:substitution.difference_item', where: { redo_scope: 'named' } },
|
||||
fields: {
|
||||
param_name: { col: 'param_name' },
|
||||
param_desc: { col: 'param_desc' },
|
||||
param_name: { col: 'parameter_name' },
|
||||
param_desc: { col: 'parameter_desc' },
|
||||
constraint_type: { col: 'constraint_type' },
|
||||
unit: { col: 'param_unit' },
|
||||
original_value: { lookup: 'parts.parameter', by: { internal_pn: { in: 'originalPn' }, param_name: { col: 'param_name' } }, take: 'param_value', else: '' },
|
||||
original_note: { lookup: 'parts.parameter', by: { internal_pn: { in: 'originalPn' }, param_name: { col: 'param_name' } }, take: 'param_note', else: '' },
|
||||
candidate_value: { lookup: 'parts.parameter', by: { internal_pn: { in: 'candidatePn' }, param_name: { col: 'param_name' } }, take: 'param_value', else: '' },
|
||||
candidate_note: { lookup: 'parts.parameter', by: { internal_pn: { in: 'candidatePn' }, param_name: { col: 'param_name' } }, take: 'param_note', else: '' },
|
||||
unit: { col: 'parameter_unit' },
|
||||
original_value: { col: 'original_value' },
|
||||
candidate_value: { col: 'candidate_value' },
|
||||
/* 值的备注不在明细表上,回台账现取 —— 与第一轮同一份事实来源 */
|
||||
original_note: { lookup: 'parts.parameter', by: { internal_pn: { in: 'originalPn' }, param_name: { col: 'parameter_name' } }, take: 'param_note', else: '' },
|
||||
candidate_note: { lookup: 'parts.parameter', by: { internal_pn: { in: 'candidatePn' }, param_name: { col: 'parameter_name' } }, take: 'param_note', else: '' },
|
||||
/* 上一轮的结论 —— 含人就地改过的那几行(读的是本单草稿的当下值) */
|
||||
last_status: { lookup: 'mine:substitution.difference_item', by: { parameter_name: { col: 'param_name' } }, take: 'difference_status', else: '' },
|
||||
last_impact: { lookup: 'mine:substitution.difference_item', by: { parameter_name: { col: 'param_name' } }, take: 'impact_statement', else: '' },
|
||||
last_evidence: { lookup: 'mine:substitution.difference_item', by: { parameter_name: { col: 'param_name' } }, take: 'evidence_note', else: '' },
|
||||
last_unknown_disposition: { lookup: 'mine:substitution.difference_item', by: { parameter_name: { col: 'param_name' } }, take: 'unknown_disposition', else: '' },
|
||||
/* 人这次打回写的那句话 —— 每一行都带一份(入参只有行这一种形状),指令里说明它是整批的意见 */
|
||||
last_status: { col: 'difference_status' },
|
||||
last_impact: { col: 'impact_statement' },
|
||||
last_evidence: { col: 'evidence_note' },
|
||||
last_unknown_disposition: { col: 'unknown_disposition' },
|
||||
/* 人这次打回写的那句话 —— 每一行都带一份(入参只有行这一种形状) */
|
||||
reviewer_note: { in: 'case_redo_note' },
|
||||
},
|
||||
},
|
||||
output: ASSESS_OUTPUT,
|
||||
} as const;
|
||||
|
||||
/** 复核轮判完之后落回明细 —— 与第一轮同一笔投影,同样只在被打回的那一轮跑 */
|
||||
const DIFFERENCE_ITEM_FROM_REDO = { ...DIFFERENCE_ITEM_FROM_RESULT, when: 'case_redo_note != ""' } as const;
|
||||
/**
|
||||
* ④ 判完写回 —— **同样只写被点名的那几行**(`from` 里压根没有别的行)。
|
||||
* 模型漏答某一条时 `else` 兜回这一行上一轮的值:漏答不该变成「把它清空」。
|
||||
*/
|
||||
const DIFFERENCE_ITEM_FROM_REDO = {
|
||||
kind: 'project' as const,
|
||||
when: 'case_redo_note != ""',
|
||||
into: 'substitution.difference_item',
|
||||
from: { each: 'mine:substitution.difference_item', where: { redo_scope: 'named' } },
|
||||
fields: {
|
||||
substitution_relation_id: { col: 'substitution_relation_id' },
|
||||
difference_item_id: { col: 'difference_item_id' },
|
||||
constraint_type: { col: 'constraint_type' },
|
||||
difference_status: { lookup: 'result:items', by: { param_name: { col: 'parameter_name' } }, take: 'difference_status', else: { col: 'difference_status' } },
|
||||
impact_statement: { lookup: 'result:items', by: { param_name: { col: 'parameter_name' } }, take: 'impact_statement', else: { col: 'impact_statement' } },
|
||||
evidence_note: { lookup: 'result:items', by: { param_name: { col: 'parameter_name' } }, take: 'evidence_note', else: { col: 'evidence_note' } },
|
||||
unknown_disposition: { lookup: 'result:items', by: { param_name: { col: 'parameter_name' } }, take: 'unknown_disposition', else: { col: 'unknown_disposition' } },
|
||||
/* 派生列与两处创建笔共用同一份 when 链 —— 四态一变,判定分类与风险跟着变 */
|
||||
...JUDGEMENT_DERIVED_FIELDS,
|
||||
},
|
||||
} as const;
|
||||
|
||||
export const ASSESSMENT_STEPS = [
|
||||
{
|
||||
@@ -868,10 +928,13 @@ export const ASSESSMENT_STEPS = [
|
||||
let: SHARED_LET,
|
||||
do: [
|
||||
/*
|
||||
* ①② **人打回时,把他的意见连同上一轮结论交回给 AI 重判**(2026-09-01 用户定)——
|
||||
* 只在被打回的那一轮跑(`case_redo_note != ""`),常路(第一次送审)这两笔跳过。
|
||||
* ①-④ **人打回那一轮:先圈出他点名的是哪几条,只把这几条交回给 AI 重判**
|
||||
* (2026-09-01;第一版整表重判,当天被实测打脸 —— 见 `REDO_SCOPE_MARK` 上面那段头注)。
|
||||
* 常路(第一次送审)这四笔全跳过(`case_redo_note` 是空串),整单仍然只调一次模型。
|
||||
* 判完落回明细,后面三笔重算照旧走:派生列跟着新四态变,等级、风险、验证记录跟着变。
|
||||
*/
|
||||
REDO_SCOPE_MARK,
|
||||
REDO_SCOPE_WIDEN,
|
||||
REVIEW_REDO_ANALYZE,
|
||||
DIFFERENCE_ITEM_FROM_REDO,
|
||||
/*
|
||||
|
||||
@@ -54,7 +54,7 @@ export const manifest: ActivityManifest = {
|
||||
activityId: ACTIVITY_ID,
|
||||
name: 'ACT-WORK-05 · 差异评估',
|
||||
/* 重写不是改 —— 同版重装是 no-op(静默丢失,踩过) */
|
||||
packageVersion: '2.17.0',
|
||||
packageVersion: '2.18.0',
|
||||
category: '需求分析与方案匹配',
|
||||
sdkVersion: '0.1.0-m5',
|
||||
checksum: 'dev-checksum-part-substitution-assessment',
|
||||
@@ -529,6 +529,14 @@ export const manifest: ActivityManifest = {
|
||||
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: 'rule_version', type: 'text', label: '差异规则版本', required: true }),
|
||||
/*
|
||||
* **这一轮复核点到了哪几条**(2026-09-01 用户实测:「我打回让修改工作温度的结论,
|
||||
* 给我改了静态电流的结论」)—— 人打回时写的那句话里点了名的行标 `named`,其余 `kept`。
|
||||
* 谁可以变由这一列说了算(**行由确定的那一侧决定,不由 AI 决定** —— 规范 §4.6 纪律一):
|
||||
* 只有 `named` 的行才进重判的入参、也只有它们会被写回;`kept` 的行 AI 连见都见不到。
|
||||
* 意见一条都没点到时另有一笔把整表标 `named`(那种意见说的是整批,不是某一条)。
|
||||
*/
|
||||
col({ name: 'redo_scope', type: 'text', label: '本轮复核范围', tally: ['named', 'kept'] }),
|
||||
],
|
||||
},
|
||||
/* P-06 验证记录:一单一行,关联的是本单案号(P-01 不在本活动里,顶掉 request_id) */
|
||||
|
||||
@@ -11,13 +11,13 @@ import type { LandedFacts, Task } from '../contract.ts';
|
||||
import { createTaskService } from '../internal/usecase/task-service.ts';
|
||||
import type { TaskServiceDeps } from '../internal/usecase/task-service.ts';
|
||||
|
||||
function harness(lastProgressAt: Date | undefined) {
|
||||
function harness(lastProgressAt: Date | undefined, runtime: Task['runtime'] = 'awaiting-human') {
|
||||
const task: Task = {
|
||||
id: 't-1' as TaskId,
|
||||
activityId: 'w05',
|
||||
ownerId: 's-1' as StaffId,
|
||||
title: 'x',
|
||||
runtime: 'awaiting-human',
|
||||
runtime,
|
||||
envelope: {},
|
||||
data: {},
|
||||
caps: { steps: 40, tokens: 200000, humanCalls: 4, activeMinutes: 60 },
|
||||
@@ -88,6 +88,29 @@ describe('迟到的人事件', () => {
|
||||
expect(arrival?.detail?.['stale']).toBe(true);
|
||||
});
|
||||
|
||||
/*
|
||||
* **判了 stale 还得管它有没有人叫醒**(2026-09-01,两次实测撞停):卡发出 270ms 后人就答了 ——
|
||||
* 把 `lastProgressAt` 往前挪的那一拍,**正是发出这张卡的那一拍**,它不可能消费一条当时还不存在的回传;
|
||||
* 而回传口的 `wake` 也白做了(那一拍随后收尾,把任务 park 回 `awaiting-event`,晚到的写盖了早到的)。
|
||||
* 于是卡答完了、没有新卡在等、单子停着,**再没有第三样东西会叫醒它** —— 实测停了 15 分钟,
|
||||
* 手工把 runtime 拨回 running,同一份代码立刻把该走的几拍走完。
|
||||
* 这一拍照旧不跑(stale 的本意不变),但停着的单子要拨回 running 交给推进器。
|
||||
*/
|
||||
it('**stale 但单子停着** → 这一拍照旧不跑,可要把它拨回 running,不然再没人叫醒它', async () => {
|
||||
const h = harness(new Date('2026-08-27T09:48:00.200Z'));
|
||||
const out = await h.service.deliver('t-1' as TaskId, { kind: 'human', ref: 'card-p10', payload: {}, occurredAt: REPLY_AT });
|
||||
expect(h.advanced()).toBe(0);
|
||||
expect(h.onEvents()).toBe(0);
|
||||
expect(out.task.runtime).toBe('running');
|
||||
});
|
||||
|
||||
it('stale 而单子本来就在跑 → 一个字不动(推进器自己会跑到它)', async () => {
|
||||
const h = harness(new Date('2026-08-27T09:48:00.200Z'), 'running');
|
||||
const out = await h.service.deliver('t-1' as TaskId, { kind: 'human', ref: 'card-p10', payload: {}, occurredAt: REPLY_AT });
|
||||
expect(out.task.runtime).toBe('running');
|
||||
expect(h.advanced()).toBe(0);
|
||||
});
|
||||
|
||||
it('回传之后没推进过 → 照常投递并推一拍(这就是叫醒它的那一下)', async () => {
|
||||
const h = harness(new Date('2026-08-27T09:47:40.000Z'));
|
||||
await h.service.deliver('t-1' as TaskId, { kind: 'human', ref: 'card-s1', payload: {}, occurredAt: REPLY_AT });
|
||||
|
||||
@@ -350,7 +350,26 @@ export function createTaskService(deps: TaskServiceDeps): TaskService {
|
||||
detail: { ...event.payload, kind: event.kind, ...(stale ? { stale: true, note: '这条回传在到达前已被推进过的那一拍处理,这次不再推' } : {}) },
|
||||
});
|
||||
if (stale) {
|
||||
/*
|
||||
* **判了 stale 还得管它有没有人叫醒** —— 不然就是把单子锁死(2026-09-01 实测两次:
|
||||
* 卡发出 270ms 后人就答了,而**把 `lastProgressAt` 往前挪的那一拍,正是发出这张卡的那一拍**
|
||||
* ——它不可能消费一条当时还不存在的回传。上面那条 stale 判据的前提在这种时序下不成立。
|
||||
*
|
||||
* 更糟的是回传路由的 `wake` 也白做了:它先把任务拨成 `running`,而发卡那一拍**随后**收尾时
|
||||
* 又把它 park 回 `awaiting-event`(晚到的写覆盖了早到的 wake)。于是三样东西凑齐:
|
||||
* 卡答完了、没有新卡在等、单子停着,**再没有第三样东西会叫醒它**(实测停了 15 分钟,
|
||||
* 手工把 runtime 拨回 running,同一份代码立刻把该走的几拍走完)。
|
||||
*
|
||||
* 这里只补最后一下:**不跑这一拍**(stale 的本意照旧 —— 这条回传不该再推一遍),
|
||||
* 但把停着的单子拨回 `running`,交给推进器按它自己的节奏跑。真没事可干,它自己再停回去
|
||||
* (推进器那一拍会走「有卡在等人 → 只算不问模型」或直接原地返回,代价是一拍空转)。
|
||||
*/
|
||||
const held = await require(taskId);
|
||||
if (held.terminal === undefined && (held.runtime === 'awaiting-event' || held.runtime === 'awaiting-human')) {
|
||||
await deps.store.update(taskId, { runtime: 'running' });
|
||||
await deps.interaction.setPhase(taskId, 'active');
|
||||
return { task: await require(taskId), verdict: { kind: 'ok' }, progressed: false };
|
||||
}
|
||||
return { task: held, verdict: { kind: 'ok' }, progressed: false };
|
||||
}
|
||||
|
||||
|
||||
+34
-1
@@ -1721,7 +1721,14 @@ B 表却**不在**同一份 `only` 名单里——B 表对应的那一行仍留
|
||||
|
||||
---
|
||||
|
||||
## 人答得太快,那条回传被判 `stale`,单子就此没人叫醒(2026-08-31 夜,未修)
|
||||
## ~~人答得太快,那条回传被判 `stale`,单子就此没人叫醒~~(2026-08-31 夜发现 → **2026-09-01 已修**)
|
||||
|
||||
**已修**:`task-service.deliver` 判了 stale 之后**照旧不跑这一拍**(stale 的本意不变),
|
||||
但把停着的单子拨回 `running` 交给推进器 —— 三样凑齐时(卡答完了、没有新卡在等、单子停着)
|
||||
再没有第三样东西会叫醒它,补的就是最后这一下。真没事可干,它自己再停回去(代价一拍空转)。
|
||||
`deliver-stale.test.ts` 两条钉死(停着的拨回 running / 本来就在跑的一个字不动),变异验证过。
|
||||
下面是当时的诊断,原样留着 —— 指纹与病理都对。
|
||||
|
||||
|
||||
**实测指纹**(e2e w05 案例 0,ACT-WORK-05):
|
||||
|
||||
@@ -1755,3 +1762,29 @@ B 表却**不在**同一份 `only` 名单里——B 表对应的那一行仍留
|
||||
**别去放宽 stale 守卫本身** —— 它治的是另一个真病(晚到十几秒的事件把没人答的卡收掉,
|
||||
2026-08-27 实测),两件事不要混。
|
||||
|
||||
---
|
||||
|
||||
## 审核卡上的「本轮结论」在重判之后会过期(2026-09-01,未修)
|
||||
|
||||
**实测**(柴浩那一单 f14d94de):两张审核卡的 `本轮结论` 都写着
|
||||
「共 7 项核心参数:0 项一致 / 5 项硬约束不符 / 2 项软约束不符」,而第二张发出去的那一刻
|
||||
草稿里已经是 **1 项一致 / 5 硬 / 1 软**(重判把一条从 soft_mismatch 翻成了 match)。
|
||||
卡上那一行说的是上一轮的数。
|
||||
|
||||
**根因不是 bug,是两条正确规矩撞在一起**:
|
||||
- 卡的 `本轮结论` 取自 `substitution.relation.difference_summary`;
|
||||
- 而 S3 用的是 `RELATION_RECOMPUTE`(只重算 `recommendation_level`),**故意不碰**收口四格
|
||||
（推荐理由 / 差异摘要 / 风险 / 验证要求)—— 2026-08-31 用户定「这四格人可以就地改」,
|
||||
每跑一次就按规则重写会把人写的话冲掉。
|
||||
|
||||
于是:等级会跟着重判变(判据核心那条链没断),**摘要这句话不会**。
|
||||
|
||||
**要治**(方向,未验证):
|
||||
- 卡面那一行改成**按基座读数当场拼**(不读 `difference_summary`)—— 但拼法与
|
||||
`RELATION_PROJECTION.difference_summary` 会成为两处真源,得先把拼法抽成一处;
|
||||
- 或者给 `difference_summary` 一个「人动过没有」的记号:人没改过就随重判重写,改过就留着。
|
||||
记号本身要是基座数得出来的(别又变成模型自报)。
|
||||
|
||||
**先别做的理由**:它只影响卡上那一句话,件上逐条明细与等级都是真的;而两种治法都要动
|
||||
「人可改的格子」这条已经踩过坑的边界(2026-08-31:「人改完一保存就被冲掉」),值得单独一轮。
|
||||
|
||||
|
||||
@@ -709,6 +709,16 @@ const SUITES = {
|
||||
* 这一趟往返没被揉坏——是内容正确性检查,不是归属检查。
|
||||
*/
|
||||
expectFinalValue: { address: 'substitution.relation', where: 'candidate_internal_pn', equals: 'XL2596S-5.0', column: 'recommendation_level', contains: 'conditional' },
|
||||
/*
|
||||
* **打回只许动被点名的那几条**(2026-09-01 用户实测:「我打回让修改工作温度的结论,
|
||||
* 给我改了静态电流的结论」)。这条意见点名的是「使能阈值」——
|
||||
* 交回之前先把明细存一份,收工时逐行比:名字没出现在意见里的行,四态与三段叙述一个字都不许变。
|
||||
*/
|
||||
expectRedoTouchesOnlyNamed: {
|
||||
address: 'substitution.difference_item',
|
||||
nameCol: 'parameter_name',
|
||||
cols: ['difference_status', 'impact_statement', 'evidence_note', 'unknown_disposition'],
|
||||
},
|
||||
/*
|
||||
* **跨案例隔离**(2026-08-30,协调者裁定①)—— 这一例为了让 `distinct=1` 成立,
|
||||
* 把**原 PN(LM2596S-5.0,案例 1/2 也在用它)**转挂到新建的 type_id=90;这一改
|
||||
@@ -1339,6 +1349,10 @@ async function runCase(suite, kase) {
|
||||
let dataCardSeen = false;
|
||||
/** w05「都在库」:匹配**验收工单**那一段的执行卡出现过 —— 数据齐了也要叫人一次 */
|
||||
let acceptCardSeen = false;
|
||||
/** 打回之前的明细快照(`expectRedoTouchesOnlyNamed`)—— 只存第一份 */
|
||||
let redoBefore;
|
||||
/** 放行前的最后一份明细快照 —— 放行会清空草稿层,收工时取不到 */
|
||||
let redoAfter;
|
||||
/** 那张卡的**面孔**不对(标题是验收工单,发出去却是执行工单)—— 2026-08-31 真撞过一次 */
|
||||
let acceptFaceWrong = false;
|
||||
/** w05「类型不一致·硬拦」:`sub_eval.case.gate_reason` 命中过 `kase.expectGateReason` 那个词 */
|
||||
@@ -1446,6 +1460,19 @@ async function runCase(suite, kase) {
|
||||
gateReasonMatched = caseRow !== undefined && kase.expectGateReason.test(String(caseRow['gate_reason'] ?? ''));
|
||||
}
|
||||
|
||||
/*
|
||||
* 打回之前把明细存一份(2026-09-01)—— 收工时拿它逐行比「没点名的行有没有被动过」。
|
||||
* 存在**答卡之前**:答完那一拍配方就重判了,再存就晚了。
|
||||
*/
|
||||
if (kase.expectRedoTouchesOnlyNamed !== undefined) {
|
||||
const rows = draftRows(body.drafts ?? [], kase.expectRedoTouchesOnlyNamed.address);
|
||||
/* 第一份 = 打回之前(S2 刚判完那一版);此后每轮覆盖,**留住放行前的最后一份** ——
|
||||
放行会把草稿并进正式表并清空,收工时再取就什么都没有了(实测踩到) */
|
||||
if (rows.length > 0) {
|
||||
if (redoBefore === undefined) redoBefore = rows.map((r) => ({ ...r }));
|
||||
redoAfter = rows.map((r) => ({ ...r }));
|
||||
}
|
||||
}
|
||||
// 决策卡挂在对话区,不在这一摞里 —— 每轮顺手看一眼有没有等着人点的
|
||||
decisions += await answerDecisions(taskId, kase, decided);
|
||||
await answerEntries(taskId, kase, entered);
|
||||
@@ -1678,6 +1705,30 @@ async function runCase(suite, kase) {
|
||||
console.log(' ⚠️ 这一例没有要补的数据,却派出了一张数据工单 —— 判失败');
|
||||
ok = false;
|
||||
}
|
||||
if (kase.expectRedoTouchesOnlyNamed !== undefined) {
|
||||
/* `address` 在轮询那一头取快照时用过,这儿只比对已经存下来的两份 */
|
||||
const { nameCol, cols } = kase.expectRedoTouchesOnlyNamed;
|
||||
const note = (kase.decideSeq ?? []).find((d) => String(d).startsWith('custom:')) ?? '';
|
||||
const after = redoAfter ?? [];
|
||||
if (redoBefore === undefined || redoBefore.length === 0 || after.length === 0) {
|
||||
console.log(' ⚠️ 打回前后的明细没取到,「只动被点名的行」这条没验成 —— 判失败');
|
||||
ok = false;
|
||||
} else {
|
||||
const moved = [];
|
||||
for (const row of after) {
|
||||
const name = String(row[nameCol] ?? '');
|
||||
// 被点名的那几行本来就该变
|
||||
if (name === '' || note.includes(name)) continue;
|
||||
const was = redoBefore.find((r) => String(r[nameCol] ?? '') === name);
|
||||
if (was === undefined) continue;
|
||||
for (const col of cols) if (String(was[col] ?? '') !== String(row[col] ?? '')) moved.push(`${name}.${col}`);
|
||||
}
|
||||
if (moved.length > 0) {
|
||||
console.log(` ⚠️ 打回只点了名的那几条,没点名的行却被改了:${moved.join('、')} —— 判失败`);
|
||||
ok = false;
|
||||
} else console.log(' 打回只动了被点名的那几条,其余行一个字没变');
|
||||
}
|
||||
}
|
||||
if (kase.expectAcceptCard && !acceptCardSeen) {
|
||||
console.log(' ⚠️ 数据齐了也该叫人一次(只读的验收工单),一张都没见到 —— 判失败(多半是 S1 又被拍首的 doneWhen 扫描收掉了)');
|
||||
ok = false;
|
||||
|
||||
Reference in New Issue
Block a user