Skip to content

Commit 2ab0b7e

Browse files
committed
fix(dream): 收掉 #535 评审意见:审计行回读改用本次 rowid、coverage 降级并入 verdict、raw_output 文档语义
CodeRabbit 在 PR #535 上提了三条,逐条处理: ① Major:auditRef.id 可能指到别人的行 saveLlmAudit 原来先 INSERT、再 SELECT ... ORDER BY id DESC LIMIT 1 回读。 本库支持多进程共用同一个 store(busy_timeout + WAL),另一个写者在两条 语句之间插入,回读到的就不是本次调用——调用方拿这个 id 去 annotate 时, 会把本轮校验判决写到另一轮的审计行上。 改为取 .run() 返回的 lastInsertRowid 再按主键回读:那是连接内的事实, 不随并发写漂移。src/ 此前没有用过这个 API,是本 PR 新引入的写法。 ② Minor:coverageShortfall 没进 verdict 覆盖率不足(模型给了合法子集、但没有一条被逐条跳过)同样是校验层的降级: dream_runs 会记 status=degraded(#104 方向 1),而审计 metadata 写了 verdict=ok——两套账在最该对齐的一格上又对不上,正是本 PR 要消灭的病。 把 coverageDegraded 并入 verdict 判据,并把 annotate 调用挪到该变量之后。 ③ Minor:STORAGE.md 里 raw_output 的语义 原先把 raw_output 和 decisions/outcome/receipt 一起归进「拆了就回放不了」, 理由不成立:它不参与回放,只是失败轮的诊断摘要,且无正文的流错误本来就是 NULL。拆成单独一行,写清「删了只丢证据、不放不出决策」。 回归测试(+3): - 覆盖率不足的轮:run.status=degraded 与 metadata.verdict=degraded 必须同源 (断言里先确认 applied=1,否则测到的还是全 keep 的 noChange 分支)。 - 同一次会话连续写三行审计,各拿回自己那行;再插一行噪声后补注,不许漂移。 - 源码锁:saveLlmAudit 体内不许再出现「取最大 id」回读(判前先剥注释, 避免解释这条坑的注释自己命中),且必须按主键 WHERE id = ? 回读。 验收: - npm test → 2561 tests / 2560 pass / 0 fail / 1 skipped - npm run sync + node scripts/check-sync.js → 81 文件一致
1 parent a1500f9 commit 2ab0b7e

6 files changed

Lines changed: 111 additions & 27 deletions

File tree

‎dsh-mneme/docs/STORAGE.md‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,8 @@ dsh-mneme reclaim --json # 原始 JSON,给脚本用
3030
| 对象 | 动作 | 为什么零损失 |
3131
|---|---|---|
3232
| `dream_runs.input`(窗口外) | 置空 | 它是当时的记忆库快照,可由记忆库重建 |
33-
| `dream_runs` 的骨架 / `decisions` / `outcome` / `receipt` / `raw_output` | 不动 | 不可重建:拆了就回放不了那次裁决。`raw_output` 是失败轮留下的模型原文头尾(#534),原文只在那一次调用里存在过,日志滚掉就再也拿不回来 |
33+
| `dream_runs` 的骨架 / `decisions` / `outcome` / `receipt` | 不动 | 不可重建:拆了就回放不了那次裁决 |
34+
| `dream_runs.raw_output` | 不动 | 失败轮的诊断摘要(#534):收到文本但解析或校验失败时留下的原文头尾,只在那一次调用里存在过,日志滚掉就再也拿不回来。**它不参与回放**——删了不会让保留的决策放不出来,只是丢掉「模型当时到底吐了什么」这条证据;无正文的流错误本来就是 `NULL` |
3435
| `memories.embedding`(`archived = 1`) | 置空 | 检索恒带 `archived = 0`,按定义不可达 |
3536
| `memories` 的行 | 一条不删 | 本入口止体积不止条数;条数与重复归 #254 与整理动作面 |
3637
| 活跃行的向量 | 不动 | 检索正在用 |

‎dsh-mneme/lib/dream.js‎

Lines changed: 16 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1415,17 +1415,6 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
14151415
});
14161416
}
14171417
const skippedInvalid = skipped.length > 0;
1418-
// 校验通过(可能带若干跳过 → degraded)。判决同样补回审计行:这一步之前
1419-
// 没有任何地方能回答「调用成功的那一轮,决策层到底认不认」。
1420-
annotateAudit(decisionValidationMeta({
1421-
verdict: skippedInvalid ? "degraded" : "ok",
1422-
errors,
1423-
skipped,
1424-
// 校验器已就地 splice:这个长度就是下游 apply/audit 真正会消费的条目数
1425-
// (含隐式补齐的 keep)。不能再减 skipped.length——被跳过的那些早被剪掉了,
1426-
// 再减一次会把「跳 1 条、存活 1 条」算成 0(本分支自测当场抓到过)。
1427-
survivorCount: decisions.length
1428-
}));
14291418
if (skippedInvalid) {
14301419
logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped (run degrades): ${skipped.map((s) => s.error).join("; ")}`);
14311420
}
@@ -1435,6 +1424,22 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
14351424
if (coverageDegraded) {
14361425
logger?.warn?.(`dsh-mneme dream: ${coverageShortfall} (run degrades: valid subset applied, unclaimed ids kept implicitly)`);
14371426
}
1427+
// 校验通过(可能带若干跳过、也可能只是覆盖率不足 → degraded)。判决补回审计行:
1428+
// 这一步之前没有任何地方能回答「调用成功的那一轮,决策层到底认不认」。
1429+
//
1430+
// verdict 必须与下方状态判定同源(CodeRabbit on #535):coverageShortfall 同样是
1431+
// 校验层的降级,若这里只认 skippedInvalid,覆盖率不足的轮会被 dream_runs 记成
1432+
// degraded、审计 metadata 却写 ok——两套账在最该对齐的一格上又对不上,正是本
1433+
// PR 要消灭的病。
1434+
annotateAudit(decisionValidationMeta({
1435+
verdict: skippedInvalid || coverageDegraded ? "degraded" : "ok",
1436+
errors,
1437+
skipped,
1438+
// 校验器已就地 splice:这个长度就是下游 apply/audit 真正会消费的条目数
1439+
// (含隐式补齐的 keep)。不能再减 skipped.length——被跳过的那些早被剪掉了,
1440+
// 再减一次会把「跳 1 条、存活 1 条」算成 0(本分支自测当场抓到过)。
1441+
survivorCount: decisions.length
1442+
}));
14381443

14391444
// Capture pre-update snapshots so the audit records what each update changed.
14401445
const updateSnapshots = {};

‎dsh-mneme/lib/store.js‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2471,7 +2471,7 @@ export function createStore(path) {
24712471
const now = nowIso();
24722472
const inTokens = Number.isFinite(entry.input_tokens) ? entry.input_tokens : 0;
24732473
const outTokens = Number.isFinite(entry.output_tokens) ? entry.output_tokens : 0;
2474-
db.prepare(
2474+
const info = db.prepare(
24752475
`INSERT INTO llm_audit_logs (timestamp, trigger_source, operation_type, model_id,
24762476
input_tokens, output_tokens, total_tokens, cost_usd, duration_ms, status,
24772477
error_message, related_memory_ids, metadata, session_key)
@@ -2494,7 +2494,12 @@ export function createStore(path) {
24942494
: null,
24952495
entry.session_key ?? null
24962496
);
2497-
return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs ORDER BY id DESC LIMIT 1").get());
2497+
// #534 / CodeRabbit on #535:回读必须用**这一次插入**的 rowid,不能用
2498+
// `ORDER BY id DESC LIMIT 1`。库支持多进程共用(见 AGENTS.md 的
2499+
// busy_timeout + WAL 约定),另一个写者在这两条语句之间插入就会把这行
2500+
// 读成别人的调用——调用方拿它去 annotate 校验判决时,会把本轮结论写到
2501+
// 另一轮头上。lastInsertRowid 是连接内的事实,不受并发写影响。
2502+
return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs WHERE id = ?").get(info.lastInsertRowid));
24982503
}
24992504

25002505
/**

‎dsh-mneme/src/dream.js‎

Lines changed: 16 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1415,17 +1415,6 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
14151415
});
14161416
}
14171417
const skippedInvalid = skipped.length > 0;
1418-
// 校验通过(可能带若干跳过 → degraded)。判决同样补回审计行:这一步之前
1419-
// 没有任何地方能回答「调用成功的那一轮,决策层到底认不认」。
1420-
annotateAudit(decisionValidationMeta({
1421-
verdict: skippedInvalid ? "degraded" : "ok",
1422-
errors,
1423-
skipped,
1424-
// 校验器已就地 splice:这个长度就是下游 apply/audit 真正会消费的条目数
1425-
// (含隐式补齐的 keep)。不能再减 skipped.length——被跳过的那些早被剪掉了,
1426-
// 再减一次会把「跳 1 条、存活 1 条」算成 0(本分支自测当场抓到过)。
1427-
survivorCount: decisions.length
1428-
}));
14291418
if (skippedInvalid) {
14301419
logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped (run degrades): ${skipped.map((s) => s.error).join("; ")}`);
14311420
}
@@ -1435,6 +1424,22 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
14351424
if (coverageDegraded) {
14361425
logger?.warn?.(`dsh-mneme dream: ${coverageShortfall} (run degrades: valid subset applied, unclaimed ids kept implicitly)`);
14371426
}
1427+
// 校验通过(可能带若干跳过、也可能只是覆盖率不足 → degraded)。判决补回审计行:
1428+
// 这一步之前没有任何地方能回答「调用成功的那一轮,决策层到底认不认」。
1429+
//
1430+
// verdict 必须与下方状态判定同源(CodeRabbit on #535):coverageShortfall 同样是
1431+
// 校验层的降级,若这里只认 skippedInvalid,覆盖率不足的轮会被 dream_runs 记成
1432+
// degraded、审计 metadata 却写 ok——两套账在最该对齐的一格上又对不上,正是本
1433+
// PR 要消灭的病。
1434+
annotateAudit(decisionValidationMeta({
1435+
verdict: skippedInvalid || coverageDegraded ? "degraded" : "ok",
1436+
errors,
1437+
skipped,
1438+
// 校验器已就地 splice:这个长度就是下游 apply/audit 真正会消费的条目数
1439+
// (含隐式补齐的 keep)。不能再减 skipped.length——被跳过的那些早被剪掉了,
1440+
// 再减一次会把「跳 1 条、存活 1 条」算成 0(本分支自测当场抓到过)。
1441+
survivorCount: decisions.length
1442+
}));
14381443

14391444
// Capture pre-update snapshots so the audit records what each update changed.
14401445
const updateSnapshots = {};

‎dsh-mneme/src/store.js‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2471,7 +2471,7 @@ export function createStore(path) {
24712471
const now = nowIso();
24722472
const inTokens = Number.isFinite(entry.input_tokens) ? entry.input_tokens : 0;
24732473
const outTokens = Number.isFinite(entry.output_tokens) ? entry.output_tokens : 0;
2474-
db.prepare(
2474+
const info = db.prepare(
24752475
`INSERT INTO llm_audit_logs (timestamp, trigger_source, operation_type, model_id,
24762476
input_tokens, output_tokens, total_tokens, cost_usd, duration_ms, status,
24772477
error_message, related_memory_ids, metadata, session_key)
@@ -2494,7 +2494,12 @@ export function createStore(path) {
24942494
: null,
24952495
entry.session_key ?? null
24962496
);
2497-
return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs ORDER BY id DESC LIMIT 1").get());
2497+
// #534 / CodeRabbit on #535:回读必须用**这一次插入**的 rowid,不能用
2498+
// `ORDER BY id DESC LIMIT 1`。库支持多进程共用(见 AGENTS.md 的
2499+
// busy_timeout + WAL 约定),另一个写者在这两条语句之间插入就会把这行
2500+
// 读成别人的调用——调用方拿它去 annotate 校验判决时,会把本轮结论写到
2501+
// 另一轮头上。lastInsertRowid 是连接内的事实,不受并发写影响。
2502+
return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs WHERE id = ?").get(info.lastInsertRowid));
24982503
}
24992504

25002505
/**

‎dsh-mneme/test/dream-decision-evidence.test.js‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -240,6 +240,69 @@ test("#534: 全部合法的轮次 verdict=ok,metadata 不因补注长出多余
240240
store.close();
241241
});
242242

243+
test("#534: 覆盖率不足(没有逐条跳过)也判 degraded,与 dream_runs.status 同源", async () => {
244+
// CodeRabbit on #535:coverageShortfall 同样是校验层降级。此前 verdict 只认
245+
// skippedInvalid,于是「模型给了合法子集、但覆盖不到半数」的轮次会落成
246+
// dream_runs.status="degraded" 而 metadata 写 verdict="ok"——两套账在最该
247+
// 对齐的一格上又对不上。这条锁把它们绑死在同一个判据上。
248+
const { store, service, dream } = setup();
249+
const ids = [];
250+
for (let i = 0; i < 5; i += 1) {
251+
ids.push(service.saveWithDedupe({ type: "project", title: `覆盖-${i}`, content: `覆盖正文-${i}`, importance: 3 }).memory.id);
252+
}
253+
const result = await dream.runDream(mockCtx({
254+
// 2/5 = 40% 覆盖 < 下限 50%,且没有一条被逐条跳过——降级理由只能是 coverage。
255+
// 必须让一条真落地(archive 掉一条):全 keep 轮会先被 noChange 分支截走
256+
// (那里 status 只由 summaryStored 决定),走不到 coverage 这一格。
257+
onConsolidation: () => JSON.stringify([
258+
{ action: "keep", ids: [ids[0]] },
259+
{ action: "archive", ids: [ids[1]], reason: "重复条目" }
260+
])
261+
}), service, { dreamImplicitKeep: true, dreamMinExplicitCoverage: 0.5 });
262+
const run = store.getDreamRun(result.runId);
263+
assert.equal(run.applied, 1, "先确认这条路径真的落地了改动(否则测的还是 noChange 分支)");
264+
assert.equal(run.status, "degraded", "覆盖率不足在 run 行上一直是 degraded(#104 方向 1)");
265+
const meta = metaOf(consolidateAudits(service)[0]);
266+
assert.equal(meta.decision_validation.verdict, "degraded", "审计 metadata 必须跟 run 行说同一件事");
267+
assert.equal(meta.decision_validation.skipped_count, 0, "这条路径没有逐条跳过,判据只能是 coverage");
268+
assert.equal(meta.decision_validation.survivor_count, 5, "未 claim 的 4 条被隐式 keep 补齐,全部存活");
269+
store.close();
270+
});
271+
272+
test("#534: 审计行的 id 来自本次插入,不是「当前最大 id」", async () => {
273+
// CodeRabbit on #535(Major):saveLlmAudit 原来先 INSERT 再
274+
// `SELECT * ORDER BY id DESC LIMIT 1`。库支持多进程共用,另一个写者插在
275+
// 中间就会把这行读成别人的调用,随后 annotate 把本轮判决写到别人头上。
276+
// 这里用「连续两次写入各自拿回自己那行」锁住回读口径。
277+
const { store, service } = setup();
278+
const first = service.saveLlmAudit({ trigger_source: "t", operation_type: "o1", model_id: "m", status: "success" });
279+
service.saveLlmAudit({ trigger_source: "t", operation_type: "o2", model_id: "m", status: "success" });
280+
const second = service.saveLlmAudit({ trigger_source: "t", operation_type: "o3", model_id: "m", status: "success" });
281+
assert.equal(first.operation_type, "o1", "回读的必须是自己插入的那一行");
282+
assert.equal(second.operation_type, "o3");
283+
assert.ok(second.id > first.id, "id 单调,但取值只认本次插入");
284+
285+
// 判决补注同样按 id 定位:插一行噪声在后面,也不能改变目标行。
286+
service.saveLlmAudit({ trigger_source: "t", operation_type: "noise", model_id: "m", status: "success" });
287+
const updated = service.annotateLlmAudit(first.id, { decision_validation: { verdict: "rejected" } });
288+
assert.equal(updated.operation_type, "o1", "补注不许漂到别的行");
289+
const rows = service.listLlmAudits({ limit: 20 });
290+
assert.equal(rows.find((r) => r.operation_type === "noise").metadata, undefined, "噪声行不许被写上本轮判决");
291+
store.close();
292+
});
293+
294+
test("#534: saveLlmAudit 不再用「取最大 id」回读(源码锁)", () => {
295+
const src = readFileSync(new URL("../src/store.js", import.meta.url), "utf8");
296+
const body = src.slice(src.indexOf("function saveLlmAudit(entry)"));
297+
const head = body.slice(0, body.indexOf("\n }\n"));
298+
// 先去注释再判:解释这条坑的注释本身会引述旧写法,不剥掉就永远命中自己。
299+
const code = head.replace(/^\s*\/\/.*$/gm, "");
300+
assert.equal(code.includes("ORDER BY id DESC LIMIT 1"), false,
301+
"多进程共用同一库时「取最大 id」会读成别人的行——必须用 lastInsertRowid");
302+
assert.match(code, /lastInsertRowid/, "回读口径锁在本次插入返回的 rowid 上");
303+
assert.match(code, /SELECT \* FROM llm_audit_logs WHERE id = \?/, "回读用主键定位,不用排序取首行");
304+
});
305+
243306
// ---------------------------------------------------------------- 改动面守卫
244307

245308
test("#534: decisions 列之外没有别的写入口往那一列塞非决策对象", () => {

0 commit comments

Comments
 (0)