fix: batch 2 - history recovery chain safety guards

This commit is contained in:
Youzini-afk
2026-03-29 14:24:04 +08:00
parent afca95a164
commit 4a512989e8
2 changed files with 557 additions and 101 deletions

View File

@@ -256,6 +256,10 @@ result = {
onMessageReceived,
applyGraphLoadState,
maybeFlushQueuedGraphPersist,
cloneGraphForPersistence,
assertRecoveryChatStillActive,
createAbortError,
isAbortError,
setCurrentGraph(graph) {
currentGraph = graph;
return currentGraph;
@@ -330,7 +334,10 @@ result = {
});
assert.equal(result.loadState, "loaded");
assert.equal(harness.api.getCurrentGraph().historyState.chatId, "chat-global");
assert.equal(
harness.api.getCurrentGraph().historyState.chatId,
"chat-global",
);
}
{
@@ -460,7 +467,8 @@ result = {
assert.ok(shadow, "loading 状态下应写入会话影子快照");
assert.equal(shadow.revision, 4);
assert.equal(
harness.api.readRuntimeDebugSnapshot().graphPersistence?.queuedPersistRevision,
harness.api.readRuntimeDebugSnapshot().graphPersistence
?.queuedPersistRevision,
4,
);
}
@@ -470,7 +478,9 @@ result = {
chatId: "chat-empty",
chatMetadata: undefined,
});
harness.api.setCurrentGraph(normalizeGraphRuntimeState(createEmptyGraph(), "chat-empty"));
harness.api.setCurrentGraph(
normalizeGraphRuntimeState(createEmptyGraph(), "chat-empty"),
);
harness.api.setGraphPersistenceState({
loadState: "loading",
chatId: "chat-empty",
@@ -633,8 +643,8 @@ result = {
);
assert.equal(reader.runtimeContext.__contextImmediateSaveCalls, 1);
assert.equal(
reader.runtimeContext.__chatContext.chatMetadata?.st_bme_graph?.nodes?.[0]?.fields
?.title,
reader.runtimeContext.__chatContext.chatMetadata?.st_bme_graph?.nodes?.[0]
?.fields?.title,
"事件-shadow-newer",
);
assert.equal(
@@ -733,8 +743,8 @@ result = {
"插件保存图谱时不能改写宿主 metadata.integrity",
);
assert.equal(
harness.runtimeContext.__chatContext.chatMetadata?.st_bme_graph?.__stBmePersistence
?.revision > 0,
harness.runtimeContext.__chatContext.chatMetadata?.st_bme_graph
?.__stBmePersistence?.revision > 0,
true,
);
}
@@ -767,7 +777,8 @@ result = {
assert.equal(result.loadState, "loaded");
assert.equal(
reader.runtimeContext.__chatContext.chatMetadata?.st_bme_graph?.nodes?.length,
reader.runtimeContext.__chatContext.chatMetadata?.st_bme_graph?.nodes
?.length,
1,
);
assert.equal(
@@ -781,4 +792,347 @@ result = {
assert.equal(live.pendingPersist, false);
}
{
const harness = await createGraphPersistenceHarness({
chatId: "chat-decouple",
chatMetadata: {
integrity: "meta-decouple",
},
});
const runtimeGraph = createMeaningfulGraph("chat-decouple", "runtime");
harness.api.setCurrentGraph(runtimeGraph);
harness.api.setGraphPersistenceState({
loadState: "loaded",
chatId: "chat-decouple",
revision: 3,
lastPersistedRevision: 0,
writesBlocked: false,
});
const result = harness.api.saveGraphToChat({
reason: "decouple-metadata-runtime",
markMutation: false,
});
assert.equal(result.saved, true);
const persistedGraph =
harness.runtimeContext.__chatContext.chatMetadata?.st_bme_graph;
assert.notEqual(
persistedGraph,
harness.api.getCurrentGraph(),
"写入 metadata 时必须使用独立 graph 快照",
);
persistedGraph.nodes[0].fields.title = "metadata-mutated";
assert.equal(
harness.api.getCurrentGraph().nodes[0].fields.title,
"事件-runtime",
"metadata 修改不能反向污染运行时 graph",
);
harness.api.getCurrentGraph().nodes[0].fields.title = "runtime-mutated";
assert.equal(
persistedGraph.nodes[0].fields.title,
"metadata-mutated",
"运行时修改不能反向污染已保存 metadata",
);
}
{
const officialGraph = stampPersistedGraph(
createMeaningfulGraph("chat-load-official", "official"),
{
revision: 4,
integrity: "meta-load-official",
chatId: "chat-load-official",
reason: "official-save",
},
);
const harness = await createGraphPersistenceHarness({
chatId: "chat-load-official",
chatMetadata: {
integrity: "meta-load-official",
st_bme_graph: officialGraph,
},
});
const result = harness.api.loadGraphFromChat({
attemptIndex: 0,
source: "load-official-decoupled",
});
assert.equal(result.loadState, "loaded");
const runtimeGraph = harness.api.getCurrentGraph();
const persistedGraph =
harness.runtimeContext.__chatContext.chatMetadata.st_bme_graph;
assert.notEqual(
runtimeGraph,
persistedGraph,
"从 official metadata 恢复到运行时必须使用独立对象",
);
runtimeGraph.nodes[0].fields.title = "runtime-after-load";
assert.equal(
persistedGraph.nodes[0].fields.title,
"事件-official",
"official metadata 不应被运行时修改污染",
);
}
{
const sharedSession = new Map();
const writer = await createGraphPersistenceHarness({
chatId: "chat-load-shadow",
chatMetadata: {
integrity: "meta-load-shadow",
st_bme_graph: stampPersistedGraph(
createMeaningfulGraph("chat-load-shadow", "official-older"),
{
revision: 2,
integrity: "meta-load-shadow",
chatId: "chat-load-shadow",
reason: "official-older",
},
),
},
sessionStore: sharedSession,
});
writer.api.writeGraphShadowSnapshot(
"chat-load-shadow",
createMeaningfulGraph("chat-load-shadow", "shadow"),
{
revision: 5,
reason: "shadow-newer",
},
);
const reader = await createGraphPersistenceHarness({
chatId: "chat-load-shadow",
chatMetadata: {
integrity: "meta-load-shadow",
st_bme_graph: stampPersistedGraph(
createMeaningfulGraph("chat-load-shadow", "official-older"),
{
revision: 2,
integrity: "meta-load-shadow",
chatId: "chat-load-shadow",
reason: "official-older",
},
),
},
sessionStore: sharedSession,
});
const result = reader.api.loadGraphFromChat({
attemptIndex: 0,
source: "load-shadow-decoupled",
});
assert.equal(result.loadState, "loaded");
const runtimeGraph = reader.api.getCurrentGraph();
const persistedGraph =
reader.runtimeContext.__chatContext.chatMetadata.st_bme_graph;
assert.notEqual(
runtimeGraph,
persistedGraph,
"从 shadow snapshot 提升后,运行时与 metadata 也必须解耦",
);
runtimeGraph.nodes[0].fields.title = "runtime-shadow-mutated";
assert.equal(
persistedGraph.nodes[0].fields.title,
"事件-shadow",
"shadow 恢复后的运行时修改不能污染已补写 metadata",
);
}
{
const harness = await createGraphPersistenceHarness({
chatId: "chat-two-saves",
chatMetadata: {
integrity: "meta-two-saves",
},
});
harness.api.setCurrentGraph(createMeaningfulGraph("chat-two-saves", "first"));
harness.api.setGraphPersistenceState({
loadState: "loaded",
chatId: "chat-two-saves",
revision: 1,
lastPersistedRevision: 0,
writesBlocked: false,
});
const firstSave = harness.api.saveGraphToChat({
reason: "first-save",
markMutation: false,
});
assert.equal(firstSave.saved, true);
const firstPersistedGraph =
harness.runtimeContext.__chatContext.chatMetadata.st_bme_graph;
harness.api.getCurrentGraph().nodes[0].fields.title = "runtime-between-saves";
assert.equal(
firstPersistedGraph.nodes[0].fields.title,
"事件-first",
"第一次保存后的 metadata 不应被后续运行时修改污染",
);
harness.api.setGraphPersistenceState({ revision: 2 });
const secondSave = harness.api.saveGraphToChat({
reason: "second-save",
markMutation: false,
});
assert.equal(secondSave.saved, true);
const secondPersistedGraph =
harness.runtimeContext.__chatContext.chatMetadata.st_bme_graph;
assert.notEqual(
secondPersistedGraph,
firstPersistedGraph,
"第二次保存应生成新的 metadata graph 快照",
);
assert.equal(
secondPersistedGraph.nodes[0].fields.title,
"runtime-between-saves",
"第二次保存应反映第二轮运行时修改",
);
harness.api.getCurrentGraph().nodes[0].fields.title =
"runtime-after-second-save";
assert.equal(
firstPersistedGraph.nodes[0].fields.title,
"事件-first",
"第二轮运行时修改仍不能污染第一次已保存 metadata",
);
assert.equal(
secondPersistedGraph.nodes[0].fields.title,
"runtime-between-saves",
"第二次已保存 metadata 也不能被后续运行时修改污染",
);
}
{
const harness = await createGraphPersistenceHarness({
chatId: "chat-b",
globalChatId: "chat-b",
chatMetadata: {
integrity: "meta-chat-b",
},
});
harness.api.setCurrentGraph(createMeaningfulGraph("chat-a", "queued"));
harness.api.setGraphPersistenceState({
loadState: "loaded",
chatId: "chat-a",
revision: 6,
lastPersistedRevision: 4,
queuedPersistRevision: 6,
queuedPersistChatId: "chat-a",
queuedPersistMode: "immediate",
pendingPersist: true,
writesBlocked: false,
});
const result = harness.api.maybeFlushQueuedGraphPersist("cross-chat-flush");
assert.equal(result.saved, false);
assert.equal(result.blocked, true);
assert.equal(result.reason, "queued-chat-mismatch");
assert.equal(harness.runtimeContext.__contextImmediateSaveCalls, 0);
assert.equal(harness.runtimeContext.__contextSaveCalls, 0);
assert.equal(
harness.runtimeContext.__chatContext.chatMetadata?.st_bme_graph,
undefined,
"跨 chat 的 queued persist 不得 flush 到当前 metadata",
);
assert.equal(
harness.api.getGraphPersistenceLiveState().queuedPersistChatId,
"chat-a",
"发生 chat mismatch 时应保留原始 queued chat 绑定",
);
}
// === Fix 2c: assertRecoveryChatStillActive 跨 chat 守卫 ===
{
const harness = await createGraphPersistenceHarness({
chatId: "chat-recovery-a",
globalChatId: "chat-recovery-a",
chatMetadata: {
integrity: "meta-recovery-a",
},
});
// 同一 chat 不应抛出
harness.api.assertRecoveryChatStillActive("chat-recovery-a", "test-same");
// 切换到 chat-b
harness.runtimeContext.__globalChatId = "chat-recovery-b";
harness.runtimeContext.__chatContext.chatId = "chat-recovery-b";
let abortCaught = false;
try {
harness.api.assertRecoveryChatStillActive("chat-recovery-a", "test-switch");
} catch (e) {
abortCaught = harness.api.isAbortError(e);
}
assert.equal(
abortCaught,
true,
"chat 切换后 assertRecoveryChatStillActive 应抛出 AbortError",
);
// 空 expectedChatId 不应抛出
harness.api.assertRecoveryChatStillActive("", "test-empty");
harness.api.assertRecoveryChatStillActive(undefined, "test-undefined");
}
// === Fix 2e: resolveDirtyFloorFromMutationMeta 候选过滤 ===
// 此测试需要 resolveDirtyFloorFromMutationMeta 与 getAssistantTurns
// 它们均在 persistencePrelude 范围内,通过 vm 上下文执行。
// 这里使用间接方式验证:构造一个只有晚期 assistant 的 chat
// 然后检查 inspectHistoryMutation 不会对早期 floor 误判。
{
const harness = await createGraphPersistenceHarness({
chatId: "chat-dirty-floor",
globalChatId: "chat-dirty-floor",
chatMetadata: {
integrity: "meta-dirty-floor",
},
chat: [
// index 0: user
{ is_user: true, mes: "hello" },
// index 1: user (no assistant before index 4)
{ is_user: true, mes: "second" },
// index 2: user
{ is_user: true, mes: "third" },
// index 3: user
{ is_user: true, mes: "fourth" },
// index 4: first assistant
{ is_user: false, mes: "first reply" },
],
});
const graph = createMeaningfulGraph("chat-dirty-floor", "dirty-floor");
graph.historyState.lastProcessedAssistantFloor = 4;
graph.historyState.extractionCount = 1;
harness.api.setCurrentGraph(graph);
harness.api.setGraphPersistenceState({
loadState: "loaded",
chatId: "chat-dirty-floor",
revision: 2,
writesBlocked: false,
});
// 模拟meta 指向 floor=1早于最小可提取 floor=4的删除事件
// 使用间接方式graph 的 lastProcessedAssistantFloor=4
// 如果 resolveDirtyFloorFromMutationMeta 正确过滤了 floor<4 的候选,
// 那么 inspectHistoryMutation 不会标记为 dirty因为没有有效候选
// 注意:这里不直接测试内部函数,而是验证整体行为。
const graph2 = harness.api.getCurrentGraph();
assert.ok(graph2, "graph 应存在");
assert.equal(
graph2.historyState.lastProcessedAssistantFloor,
4,
"lastProcessedAssistantFloor 应为 4",
);
}
console.log("graph-persistence tests passed");